File stern-1.28.0.obscpio of Package stern

Overview Repositories Revisions Requests Users Attributes Meta

File stern-1.28.0.obscpio of Package stern (Revision 7a6235221457354f59a96c207fb8af48)

Currently displaying revision 7a6235221457354f59a96c207fb8af48 , Show latest

07070100000000000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001500000000stern-1.28.0/.github07070100000001000081A4000000000000000000000001659C91000000002B000000000000000000000000000000000000002000000000stern-1.28.0/.github/CODEOWNERS*   @superbrothers @floryut @rkmathi @tksm
07070100000002000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000002400000000stern-1.28.0/.github/ISSUE_TEMPLATE07070100000003000081A4000000000000000000000001659C910000000183000000000000000000000000000000000000003200000000stern-1.28.0/.github/ISSUE_TEMPLATE/bug-report.md---
name: Bug Report
about: Report a bug encountered while using stern
labels: kind/bug

---

**What happened**:

**What you expected to happen**:

**How to reproduce it (as minimally and precisely as possible)**:

**Anything else we need to know?**:

**Environment**:
- stern version (use `stern --version`):
- OS (e.g: `cat /etc/os-release`):
- Install tools (e.g: Homebrew)
- Others:
07070100000004000081A4000000000000000000000001659C910000000094000000000000000000000000000000000000003300000000stern-1.28.0/.github/ISSUE_TEMPLATE/enhancement.md---
name: Enhancement Request
about: Suggest an enhancement
labels: kind/feature

---
**What would you like to be added**:

**Why is this needed**:
07070100000005000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001F00000000stern-1.28.0/.github/workflows07070100000006000081A4000000000000000000000001659C9100000002E8000000000000000000000000000000000000002700000000stern-1.28.0/.github/workflows/ci.yamlname: CI

on:
  # Must keep in sync with ci_for_skipped.yaml
  push:
    branches: [master]
    paths-ignore: ['**.md']
  pull_request:
    types: [opened, synchronize]
    paths-ignore: ['**.md']

jobs:
  run:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-go@v5
      with:
        go-version-file: go.mod
    - name: Ensure go.mod is already tidied
      run: go mod tidy && git diff -s --exit-code go.sum
    - name: Run verify-readme
      run: make verify-readme
    - name: Run tests
      run: make test
    - name: Build binary
      run: make build
    - name: Make dist file
      run: make dist
    - name: Validate a krew plugin manifest file
      run: make validate-krew-manifest
07070100000007000081A4000000000000000000000001659C9100000000F9000000000000000000000000000000000000003300000000stern-1.28.0/.github/workflows/ci_for_skipped.yaml# CI for skipped files
name: CI

on:
  push:
    branches: [master]
    paths: ['**.md']
  pull_request:
    types: [opened, synchronize]
    paths: ['**.md']

jobs:
  run:
    runs-on: ubuntu-latest
    steps:
    - run: 'echo "No check required"'
07070100000008000081A4000000000000000000000001659C91000000029C000000000000000000000000000000000000002C00000000stern-1.28.0/.github/workflows/release.yamlname: Release

on:
  push:
    tags: ["v*"]

jobs:
  run:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-go@v5
      with:
        go-version-file: go.mod
    - name: Login to GitHub Container Registry
      uses: docker/login-action@v3
      with:
        registry: ghcr.io
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
    - name: Release
      run: make release
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    - name: Update new version in krew-index
      uses: rajatjindal/krew-release-bot@v0.0.46
      with:
        krew_template_file: dist/krew/stern.yaml
07070100000009000081A4000000000000000000000001659C91000000001D000000000000000000000000000000000000001800000000stern-1.28.0/.gitignore/dist
/hack/tools/bin
vendor
0707010000000A000081A4000000000000000000000001659C9100000000A1000000000000000000000000000000000000001B00000000stern-1.28.0/.golangci.ymlrun:
  timeout: 5m
linters:
  disable-all: true
  enable:
  - errcheck
  - gofmt
  - gosimple
  - govet
  - ineffassign
  - staticcheck
  - typecheck
  - unused
0707010000000B000081A4000000000000000000000001659C910000000620000000000000000000000000000000000000001E00000000stern-1.28.0/.goreleaser.yamlbuilds:
- env:
  - CGO_ENABLED=0
  ldflags:
  - -s
  - -w
  - -X github.com/stern/stern/cmd.version={{.Version}}
  - -X github.com/stern/stern/cmd.commit={{.Commit}}
  - -X github.com/stern/stern/cmd.date={{.Date}}
  goos:
  - linux
  - windows
  - darwin
  goarch:
  - amd64
  - arm
  - arm64
archives:
- builds:
  - stern
  name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
  format: tar.gz
  files:
  - LICENSE
  wrap_in_directory: false
checksum:
  name_template: 'checksums.txt'
changelog:
  sort: asc
dockers:
- image_templates:
  - "ghcr.io/stern/stern:latest"
  - "ghcr.io/stern/stern:{{ .Major }}"
  - "ghcr.io/stern/stern:{{ .Major }}.{{ .Minor }}"
  - "ghcr.io/stern/stern:{{ .Major }}.{{ .Minor }}.{{ .Patch }}"
krews:
- skip_upload: true
  homepage: https://github.com/stern/stern
  description: |
    Stern allows you to `tail` multiple pods on Kubernetes and multiple containers
    within the pod. Each result is color coded for quicker debugging.

The query is a regular expression so the pod name can easily be filtered and
    you don't need to specify the exact id (for instance omitting the deployment
    id). If a pod is deleted it gets removed from tail and if a new pod is added it
    automatically gets tailed.

When a pod contains multiple containers Stern can tail all of them too without
    having to do this manually for each one. Simply specify the `container` flag to
    limit what containers to show. By default all containers are listened to.
  short_description: Multi pod and container log tailing
0707010000000C000081A4000000000000000000000001659C91000000409D000000000000000000000000000000000000001A00000000stern-1.28.0/CHANGELOG.md# v1.28.0

## :zap: Notable Changes

### Highlight matched strings in the log lines with the highlight option

Some part of a log line can be highlighted while still displaying all other logs lines.

`--highlight` flag now highlight matched strings in the log lines.

```
stern --highlight "\[error\]" .
```

# v1.27.0

## :zap: Notable Changes

### Add new template function: `toTimestamp`

The `toTimestamp` function takes in an object, a layout, and optionally a timezone. This allows for more custom time parsing, for instance, if a user doesn't care about seeing the date of the log and only the time (in their own timezone) they can use a template such as:

```
--template '{{ with $msg := .Message | tryParseJSON }}[{{ toTimestamp $msg.time "15:04:05" "Local" }}] {{ $msg.msg }}{{ end }}{{ "\n" }}'
```

### Add generic kubectl options

stern now has the generic options that kubectl has, and a new `--show-hidden-options` option.

```
$ stern --show-hidden-options
The following options can also be used in stern:
      --as string                      Username to impersonate for the operation. User could be a regular user or a service account in a namespace.
      --as-group stringArray           Group to impersonate for the operation, this flag can be repeated to specify multiple groups.
      --as-uid string                  UID to impersonate for the operation.
      --cache-dir string               Default cache directory (default "/home/ksuda/.kube/cache")
      --certificate-authority string   Path to a cert file for the certificate authority
      --client-certificate string      Path to a client certificate file for TLS
      --client-key string              Path to a client key file for TLS
      --cluster string                 The name of the kubeconfig cluster to use
      --disable-compression            If true, opt-out of response compression for all requests to the server
      --insecure-skip-tls-verify       If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure
      --request-timeout string         The length of time to wait before giving up on a single server request. Non-zero values should contain a corresponding time unit (e.g. 1s, 2m, 3h). A value of zero means don't timeout requests. (default "0")
      --server string                  The address and port of the Kubernetes API server
      --tls-server-name string         Server name to use for server certificate validation. If it is not provided, the hostname used to contact the server is used
      --token string                   Bearer token for authentication to the API server
      --user string                    The name of the kubeconfig user to use
```

The number of kubectl generic options is so large that it makes it difficult to see stern's own list of options, so we usually hide them. Use `--show-hidden-options` if you want to list.

## Changes

* Add generic cli options (#283) f315819 (Kazuki Suda)
* 281: Support toTimestamp template function (#282) 5445cd5 (Will Anderson)

# v1.26.0

## :zap: Notable Changes

### Add new template functions

The following template functions have been added in v1.26.0:

- `extractJSONParts`: Parse string as JSON and concatenate the given keys
- `tryExtractJSONParts`: Attempt to parse string as JSON and concatenate the given keys, returning text on failure

## Changes

* Fix the release workflow ([#275](https://github.com/stern/stern/pull/275)) [91d4cd6](https://github.com/stern/stern/commit/91d4cd6) (Kazuki Suda)
* Update dependencies and tools ([#273](https://github.com/stern/stern/pull/273)) [cb94677](https://github.com/stern/stern/commit/cb94677) (Takashi Kusumi)
* Possibility to extract parts of a json-message. ([#271](https://github.com/stern/stern/pull/271)) [d49142c](https://github.com/stern/stern/commit/d49142c) (Niels)
* Fix potential panic in stern.Run() ([#267](https://github.com/stern/stern/pull/267)) [dcba2dd](https://github.com/stern/stern/commit/dcba2dd) (Takashi Kusumi)
* Add log level color keys and handle default ([#264](https://github.com/stern/stern/pull/264)) [65204cc](https://github.com/stern/stern/commit/65204cc) (Jimmie Högklint)
* Fix typo in README.md ([#261](https://github.com/stern/stern/pull/261)) [d7d5a4f](https://github.com/stern/stern/commit/d7d5a4f) (Will May)
* Integrate fmt and vet checks into golangci-lint ([#260](https://github.com/stern/stern/pull/260)) [1d242bc](https://github.com/stern/stern/commit/1d242bc) (Takashi Kusumi)
* Update Github Actions dependencies ([#259](https://github.com/stern/stern/pull/259)) [9e833da](https://github.com/stern/stern/commit/9e833da) (Takashi Kusumi)

# v1.25.0

## :zap: Notable Changes

### Add support for the config file

You can now use the config file to change the default values of stern options. The default config file path is `~/.config/stern/config.yaml`.

```yaml
# <flag name>: <value>
tail: 10
max-log-requests: 999
timestamps: short
```

You can change the config file path with `--config` flag or `STERNCONFIG` environment variable.

## Changes

* Fix the heading level in README.md ([#257](https://github.com/stern/stern/pull/257)) [c2290b4](https://github.com/stern/stern/commit/c2290b4) (Kazuki Suda)
* Update dependencies and tools ([#256](https://github.com/stern/stern/pull/256)) [531f869](https://github.com/stern/stern/commit/531f869) (Kazuki Suda)
* Allow an empty config file ([#255](https://github.com/stern/stern/pull/255)) [c76ea87](https://github.com/stern/stern/commit/c76ea87) (Takashi Kusumi)
* Add support for the config file ([#254](https://github.com/stern/stern/pull/254)) [2fdc298](https://github.com/stern/stern/commit/2fdc298) (Kazuki Suda)
* Make setup-go get Go version from go.mod ([#253](https://github.com/stern/stern/pull/253)) [23feff7](https://github.com/stern/stern/commit/23feff7) (Takashi Kusumi)

# v1.24.0

## :zap: Notable Changes

### Add a short format for timestamps

`--timestamps` flag now accepts a format, one of `default` or `short`.

- `default`: the original format `2006-01-02T15:04:05.000000000Z07:00` (RFC3339Nano with trailing zeros)
- `short`: the new format `01-02 15:04:05` (time.DateTime without year).

If `--timestamps` is specified but without value, `default` is used to maintain backward compatibility.

```
$ stern --timestamps=short -n kube-system ds/kindnet --no-follow --tail 1 --only-log-lines
kindnet-hqn2k kindnet-cni 03-12 09:29:53 I0312 00:29:53.620499       1 main.go:250] Node kind-worker3 has CIDR [10.244.1.0/24]
kindnet-5f4ms kindnet-cni 03-12 09:29:53 I0312 00:29:53.374482       1 main.go:250] Node kind-worker3 has CIDR [10.244.1.0/24]
```

### Add `--node` flag to filter on a specific node

New `--node` flag allows you to filter pods on a specific node. This flag will be helpful when we debug pods on the specific node.

```
# Print a DaemonSet pod on the specific node
stern --node <NODE_NAME> daemonsets/<DS_NAME>

# Print all pods on the specific node
stern --node <NODE_NAME> --all-namespaces --no-follow --max-log-requests 1 .
```

### Highlight matched strings in the log lines with the include option

`--include` flag now highlight matched strings in the log lines.

```
stern --include "\[error\]" .
```

### Add `all` option to `--container-state` flag

`--container-state` flag now accepts `all` that is the same with specifying `running,waiting,terminated`. This change is helpful when we debug CrashLoopBackoff containers.

```
# Before
stern --container-state running,terminated,running <QUERY>

# After
stern --container-state all <QUERY>`
```

## :warning: Breaking Changes

### Add `--max-log-requests` flag to limit concurrent requests

New `--max-log-requests` flag allows you to limit concurrent requests to prevent unintentional load to a cluster. The behavior and the default are different depending on the presence of the `--no-follow` flag.

| `--no-follow` | default | behavior         |
|---------------|---------|------------------|
| specified     | 5       | limits the number of concurrent logs to request |
| not specified | 50      | exits with an error when if it reaches the concurrent limit |

If you want to change to the same behavior as before, specify a sufficiently large value for `--max-log-requests`.

### Change the default of `--container-state` flag to `all`

The default value of `--container-state` has been changed to `all` from `running`. With this change, stern will now show logs of completed (`terminated`) and CrashLoopBackoff (`waiting`) pods in addition to running pods by default.

If you want to change to the same behavior as before, explicitly specify `--container-state` to `running`.

## Changes

* Upgrade golang.org/x/net to fix a dependabot alert ([#250](https://github.com/stern/stern/pull/250)) [e26d049](https://github.com/stern/stern/commit/e26d049) (Kazuki Suda)
* Add a short format for timestamps ([#249](https://github.com/stern/stern/pull/249)) [43ab3f1](https://github.com/stern/stern/commit/43ab3f1) (Takashi Kusumi)
* Bump golangci-lint to v1.51.2 ([#248](https://github.com/stern/stern/pull/248)) [079d158](https://github.com/stern/stern/commit/079d158) (Takashi Kusumi)
* Add dynamic completion for --node flag ([#244](https://github.com/stern/stern/pull/244)) [59d4453](https://github.com/stern/stern/commit/59d4453) (Takashi Kusumi)
* Add --node flag to filter on a specific node ([#243](https://github.com/stern/stern/pull/243)) [f90f70f](https://github.com/stern/stern/commit/f90f70f) (Takashi Kusumi)
* allow flexible log parsing and formatting ([#239](https://github.com/stern/stern/pull/239)) [12a55fa](https://github.com/stern/stern/commit/12a55fa) (Dmytro Milinevskyi)
* Documenting how to get Bash completion in Krew mode ([#240](https://github.com/stern/stern/pull/240)) [24c8716](https://github.com/stern/stern/commit/24c8716) (Jesse Glick)
* Add CI for skipped files ([#241](https://github.com/stern/stern/pull/241)) [7131af2](https://github.com/stern/stern/commit/7131af2) (Takashi Kusumi)
* Replace actions/cache with setup-go's cache ([#238](https://github.com/stern/stern/pull/238)) [74952fd](https://github.com/stern/stern/commit/74952fd) (Takashi Kusumi)
* Make CI jobs faster ([#237](https://github.com/stern/stern/pull/237)) [4bb340d](https://github.com/stern/stern/commit/4bb340d) (Kazuki Suda)
* Refactor options.sternConfig() ([#236](https://github.com/stern/stern/pull/236)) [2315b23](https://github.com/stern/stern/commit/2315b23) (Takashi Kusumi)
* Return error when output option is invalid ([#235](https://github.com/stern/stern/pull/235)) [1c5aa2b](https://github.com/stern/stern/commit/1c5aa2b) (Takashi Kusumi)
* Refactor template logic ([#233](https://github.com/stern/stern/pull/233)) [371daf1](https://github.com/stern/stern/commit/371daf1) (Takashi Kusumi)
* Revert "add support to parse JSON logs ([#228](https://github.com/stern/stern/pull/228))" ([#232](https://github.com/stern/stern/pull/232)) [202f7e8](https://github.com/stern/stern/commit/202f7e8) (Dmytro Milinevskyi)
* Change the default of --container-state to `all` ([#225](https://github.com/stern/stern/pull/225)) [2502c91](https://github.com/stern/stern/commit/2502c91) (Takashi Kusumi)
* Highlight matched strings in the log lines with the include option ([#231](https://github.com/stern/stern/pull/231)) [9fbaa18](https://github.com/stern/stern/commit/9fbaa18) (Kazuki Suda)
* Support resuming from the last log when retrying ([#230](https://github.com/stern/stern/pull/230)) [52894f8](https://github.com/stern/stern/commit/52894f8) (Takashi Kusumi)
* add support to parse JSON logs ([#228](https://github.com/stern/stern/pull/228)) [72a5854](https://github.com/stern/stern/commit/72a5854) (Dmytro Milinevskyi)
* Show initContainers first when --no-follow and --max-log-requests 1 ([#226](https://github.com/stern/stern/pull/226)) [ef753f1](https://github.com/stern/stern/commit/ef753f1) (Takashi Kusumi)
* Add --max-log-requests flag to limit concurrent requests ([#224](https://github.com/stern/stern/pull/224)) [0b939c5](https://github.com/stern/stern/commit/0b939c5) (Takashi Kusumi)
* Improve handling of container termination ([#221](https://github.com/stern/stern/pull/221)) [8312782](https://github.com/stern/stern/commit/8312782) (Takashi Kusumi)
* Allow pods without labels to be selected in the resource query ([#223](https://github.com/stern/stern/pull/223)) [fc51906](https://github.com/stern/stern/commit/fc51906) (Takashi Kusumi)
* Add `all` option to --container-state flag ([#222](https://github.com/stern/stern/pull/222)) [6e0d5fc](https://github.com/stern/stern/commit/6e0d5fc) (Takashi Kusumi)

# v1.23.0

## New features

### Add `--no-follow` flag to exit when all logs have been shown

New `--no-follow` flag allows you to exit when all logs have been shown.

```
stern --no-follow .
```

### Support `<resource>/<name>` form as a query

Stern now supports a Kubernetes resource query in the form `<resource>/<name>`. Pod query can still be used.

```
stern deployment/nginx
```

The following Kubernetes resources are supported:

- daemonset
- deployment
- job
- pod
- replicaset
- replicationcontroller
- service
- statefulset

Shell completion of stern already supports this feature.

### Add --verbosity flag to set log level verbosity

New `--verbosity` flag allows you to set the log level verbosity of Kubernetes client-go. This feature is useful when you want to know how stern interacts with a Kubernetes API server in troubleshooting.

```
stern --verbosity=6 .
```

### Add --only-log-lines flag to print only log lines

New `--only-log-lines` flag allows you to print only log lines (and errors if occur). The difference between not specifying the flag and specifying it is as follows:

```
$ stern . --tail=1 --no-follow
+ nginx-cfbcb7b98-96xsv › nginx
+ nginx-cfbcb7b98-29wn7 › nginx
nginx-cfbcb7b98-96xsv nginx 2023/01/27 13:20:48 [notice] 1#1: start worker process 46
- nginx-cfbcb7b98-96xsv › nginx
nginx-cfbcb7b98-29wn7 nginx 2023/01/27 13:20:45 [notice] 1#1: start worker process 46
- nginx-cfbcb7b98-29wn7 › nginx

$ stern . --tail=1 --no-follow --only-log-lines
nginx-cfbcb7b98-96xsv nginx 2023/01/27 13:20:48 [notice] 1#1: start worker process 46
nginx-cfbcb7b98-29wn7 nginx 2023/01/27 13:20:45 [notice] 1#1: start worker process 46
```

## Changes

* Allow to specify --exclude-pod/container multiple times ([#218](https://github.com/stern/stern/pull/218)) [b04478c](https://github.com/stern/stern/commit/b04478c) (Kazuki Suda)
* Add --only-log-lines flag that prints only log lines ([#216](https://github.com/stern/stern/pull/216)) [995be39](https://github.com/stern/stern/commit/995be39) (Kazuki Suda)
* Fix typo of --verbosity flag ([#215](https://github.com/stern/stern/pull/215)) [6c6db1d](https://github.com/stern/stern/commit/6c6db1d) (Takashi Kusumi)
* Add --verbosity flag to set log level verbosity ([#214](https://github.com/stern/stern/pull/214)) [5327626](https://github.com/stern/stern/commit/5327626) (Takashi Kusumi)
* Add completion for flags with pre-defined choices ([#211](https://github.com/stern/stern/pull/211)) [e03646c](https://github.com/stern/stern/commit/e03646c) (Takashi Kusumi)
* Fix bug where container-state is ignored when no-follow specified ([#210](https://github.com/stern/stern/pull/210)) [1bbee8c](https://github.com/stern/stern/commit/1bbee8c) (Takashi Kusumi)
* Add dynamic completion for a resource query ([#209](https://github.com/stern/stern/pull/209)) [2983c8f](https://github.com/stern/stern/commit/2983c8f) (Takashi Kusumi)
* Support `<resource>/<name>` form as a query ([#208](https://github.com/stern/stern/pull/208)) [7bc45f0](https://github.com/stern/stern/commit/7bc45f0) (Takashi Kusumi)
* Fix indent in update-readme.go ([#207](https://github.com/stern/stern/pull/207)) [daf2464](https://github.com/stern/stern/commit/daf2464) (Takashi Kusumi)
* Update dependencies and tools ([#205](https://github.com/stern/stern/pull/205)) [1bcb576](https://github.com/stern/stern/commit/1bcb576) (Kazuki Suda)
* Add --no-follow flag to exit when all logs have been shown ([#204](https://github.com/stern/stern/pull/204)) [a5e581d](https://github.com/stern/stern/commit/a5e581d) (Takashi Kusumi)
* Use StringArrayVarP for --include and --exclude flags ([#196](https://github.com/stern/stern/pull/196)) [80a68a9](https://github.com/stern/stern/commit/80a68a9) (partcyborg)
* Fix the invalid command in README.md ([#193](https://github.com/stern/stern/pull/193)) [f6e76ba](https://github.com/stern/stern/commit/f6e76ba) (Kazuki Suda)
0707010000000D000081A4000000000000000000000001659C910000000393000000000000000000000000000000000000001D00000000stern-1.28.0/CONTRIBUTING.md# Contributing

If you want to submit a pull request to fix a bug or enhance an existing
feature, please first open an issue and link to that issue when you
submit your pull request.

If you have any questions about a possible submission, feel free to open
an issue too.

### Pull request process

1. Fork this repository
1. Create a branch in your fork to implement the changes. We recommend using
the issue number as part of your branch name, e.g. `1234-fixes`
1. Ensure that any documentation is updated with the changes that are required
by your fix.
1. Ensure that any samples are updated if the base image has been changed.
1. Submit the pull request. *Do not leave the pull request blank*. Explain exactly
what your changes are meant to do and provide simple steps on how to validate
your changes. Ensure that you reference the issue you created as well.
The pull request will be review before it is merged.
0707010000000E000081A4000000000000000000000001659C9100000000AB000000000000000000000000000000000000001800000000stern-1.28.0/DockerfileFROM gcr.io/distroless/static-debian10
LABEL org.opencontainers.image.source https://github.com/stern/stern
COPY stern /usr/local/bin/
ENTRYPOINT ["/usr/local/bin/stern"]
0707010000000F000081A4000000000000000000000001659C910000002C5D000000000000000000000000000000000000001500000000stern-1.28.0/LICENSE                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

"Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

(a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
07070100000010000081A4000000000000000000000001659C91000000084C000000000000000000000000000000000000001600000000stern-1.28.0/MakefileSHELL:=/usr/bin/env bash

.PHONY: build
build:
	go build -o dist/stern .

TOOLS_BIN_DIR := $(CURDIR)/hack/tools/bin
GORELEASER_VERSION ?= v1.23.0
GORELEASER := $(TOOLS_BIN_DIR)/goreleaser
GOLANGCI_LINT_VERSION ?= v1.55.2
GOLANGCI_LINT := $(TOOLS_BIN_DIR)/golangci-lint
VALIDATE_KREW_MAIFEST_VERSION ?= v0.4.4
VALIDATE_KREW_MAIFEST := $(TOOLS_BIN_DIR)/validate-krew-manifest
GORELEASER_FILTER_VERSION ?= v0.3.0
GORELEASER_FILTER := $(TOOLS_BIN_DIR)/goreleaser-filter

$(GORELEASER):
	GOBIN=$(TOOLS_BIN_DIR) go install github.com/goreleaser/goreleaser@$(GORELEASER_VERSION)

$(GOLANGCI_LINT):
	GOBIN=$(TOOLS_BIN_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION)

$(VALIDATE_KREW_MAIFEST):
	GOBIN=$(TOOLS_BIN_DIR) go install sigs.k8s.io/krew/cmd/validate-krew-manifest@$(VALIDATE_KREW_MAIFEST_VERSION)

$(GORELEASER_FILTER):
	GOBIN=$(TOOLS_BIN_DIR) go install github.com/t0yv0/goreleaser-filter@$(GORELEASER_FILTER_VERSION)

.PHONY: build-cross
build-cross: $(GORELEASER)
	$(GORELEASER) build --snapshot --clean

.PHONY: test
test: lint
	go test -v ./...

.PHONY: lint
lint: $(GOLANGCI_LINT)
	$(GOLANGCI_LINT) run

.PHONY: lint-fix
lint-fix: $(GOLANGCI_LINT)
	$(GOLANGCI_LINT) run --fix

README_FILE ?= ./README.md

.PHONY: update-readme
update-readme:
	go run hack/update-readme/update-readme.go $(README_FILE)

.PHONY: verify-readme
verify-readme:
	./hack/verify-readme.sh

.PHONY: validate-krew-manifest
validate-krew-manifest: $(VALIDATE_KREW_MAIFEST)
	$(VALIDATE_KREW_MAIFEST) -manifest dist/krew/stern.yaml -skip-install

.PHONY: dist
dist: $(GORELEASER) $(GORELEASER_FILTER)
	cat .goreleaser.yaml | $(GORELEASER_FILTER) -goos $(shell go env GOOS) -goarch $(shell go env GOARCH) | $(GORELEASER) release -f- --clean --skip=publish --snapshot

.PHONY: dist-all
dist-all: $(GORELEASER)
	$(GORELEASER) release --clean --skip=publish --snapshot

.PHONY: release
release: $(GORELEASER)
	$(GORELEASER) release --clean --skip=validate

.PHONY: clean
clean: clean-tools clean-dist

.PHONY: clean-tools
clean-tools:
	rm -rf $(TOOLS_BIN_DIR)

.PHONY: clean-dist
clean-dist:
	rm -rf ./dist
07070100000011000081A4000000000000000000000001659C9100000044ED000000000000000000000000000000000000001700000000stern-1.28.0/README.md[![Build](https://github.com/stern/stern/workflows/CI/badge.svg)](https://github.com/stern/stern/actions?query=workflow%3ACI+branch%3Amaster)
# stern

*Fork of discontinued [wercker/stern](https://github.com/wercker/stern)*

Stern allows you to `tail` multiple pods on Kubernetes and multiple containers
within the pod. Each result is color coded for quicker debugging.

The query is a regular expression or a Kubernetes resource in the form
 `<resource>/<name>` so the pod name can easily be filtered and
you don't need to specify the exact id (for instance omitting the deployment
id). If a pod is deleted it gets removed from tail and if a new pod is added it
automatically gets tailed.

## Installation

### Download binary

Download a [binary release](https://github.com/stern/stern/releases)

### Build from source

```
go install github.com/stern/stern@latest
```

### asdf (Linux/macOS)

If you use [asdf](https://asdf-vm.com/), you can install like this:
```
asdf plugin-add stern
asdf install stern latest
```

### Homebrew (Linux/macOS)

If you use [Homebrew](https://brew.sh), you can install like this:
```
brew install stern
```

### Krew (Linux/macOS/Windows)

If you use [Krew](https://krew.sigs.k8s.io/) which is the package manager for kubectl plugins, you can install like this:
```
kubectl krew install stern
```

## Usage

```
stern pod-query [flags]
```

The `pod-query` is a regular expression or a Kubernetes resource in the form `<resource>/<name>`.

The query is a regular expression when it is not a Kubernetes resource,
so you could provide `"web-\w"` to tail `web-backend` and `web-frontend` pods but not `web-123`.

When the query is in the form `<resource>/<name>` (exact match), you can select all pods belonging
to the specified Kubernetes resource, such as `deployment/nginx`.
Supported Kubernetes resources are `pod`, `replicationcontroller`, `service`, `daemonset`, `deployment`,
`replicaset`, `statefulset` and `job`.

### cli flags

flag                        | default                       | purpose
-----------------------------|-------------------------------|---------
 `--all-namespaces`, `-A`    | `false`                       | If present, tail across all namespaces. A specific namespace is ignored even if specified with --namespace.
 `--color`                   | `auto`                        | Force set color output. 'auto':  colorize if tty attached, 'always': always colorize, 'never': never colorize.
 `--completion`              |                               | Output stern command-line completion code for the specified shell. Can be 'bash', 'zsh' or 'fish'.
 `--config`                  | `~/.config/stern/config.yaml` | Path to the stern config file
 `--container`, `-c`         | `.*`                          | Container name when multiple containers in pod. (regular expression)
 `--container-state`         | `all`                         | Tail containers with state in running, waiting, terminated, or all. 'all' matches all container states. To specify multiple states, repeat this or set comma-separated value.
 `--context`                 |                               | The name of the kubeconfig context to use
 `--ephemeral-containers`    | `true`                        | Include or exclude ephemeral containers.
 `--exclude`, `-e`           | `[]`                          | Log lines to exclude. (regular expression)
 `--exclude-container`, `-E` | `[]`                          | Container name to exclude when multiple containers in pod. (regular expression)
 `--exclude-pod`             | `[]`                          | Pod name to exclude. (regular expression)
 `--field-selector`          |                               | Selector (field query) to filter on. If present, default to ".*" for the pod-query.
 `--highlight`, `-H`         | `[]`                          | Log lines to highlight. (regular expression)
 `--include`, `-i`           | `[]`                          | Log lines to include. (regular expression)
 `--init-containers`         | `true`                        | Include or exclude init containers.
 `--kubeconfig`              |                               | Path to the kubeconfig file to use for CLI requests.
 `--max-log-requests`        | `-1`                          | Maximum number of concurrent logs to request. Defaults to 50, but 5 when specifying --no-follow
 `--namespace`, `-n`         |                               | Kubernetes namespace to use. Default to namespace configured in kubernetes context. To specify multiple namespaces, repeat this or set comma-separated value.
 `--no-follow`               | `false`                       | Exit when all logs have been shown.
 `--node`                    |                               | Node name to filter on.
 `--only-log-lines`          | `false`                       | Print only log lines
 `--output`, `-o`            | `default`                     | Specify predefined template. Currently support: [default, raw, json, extjson, ppextjson]
 `--prompt`, `-p`            | `false`                       | Toggle interactive prompt for selecting 'app.kubernetes.io/instance' label values.
 `--selector`, `-l`          |                               | Selector (label query) to filter on. If present, default to ".*" for the pod-query.
 `--show-hidden-options`     | `false`                       | Print a list of hidden options.
 `--since`, `-s`             | `48h0m0s`                     | Return logs newer than a relative duration like 5s, 2m, or 3h.
 `--tail`                    | `-1`                          | The number of lines from the end of the logs to show. Defaults to -1, showing all logs.
 `--template`                |                               | Template to use for log lines, leave empty to use --output flag.
 `--template-file`, `-T`     |                               | Path to template to use for log lines, leave empty to use --output flag. It overrides --template option.
 `--timestamps`, `-t`        |                               | Print timestamps with the specified format. One of 'default' or 'short'. If specified but without value, 'default' is used.
 `--timezone`                | `Local`                       | Set timestamps to specific timezone.
 `--verbosity`               | `0`                           | Number of the log level verbosity
 `--version`, `-v`           | `false`                       | Print the version and exit.

See `stern --help` for details

Stern will use the `$KUBECONFIG` environment variable if set. If both the
environment variable and `--kubeconfig` flag are passed the cli flag will be
used.

### config file

You can use the config file to change the default values of stern options. The default config file path is `~/.config/stern/config.yaml`.

```yaml
# <flag name>: <value>
tail: 10
max-log-requests: 999
timestamps: short
```

You can change the config file path with `--config` flag or `STERNCONFIG` environment variable.

### templates

stern supports outputting custom log messages.  There are a few predefined
templates which you can use by specifying the `--output` flag:

| output    | description                                                                                           |
|-----------|-------------------------------------------------------------------------------------------------------|
| `default` | Displays the namespace, pod and container, and decorates it with color depending on --color           |
| `raw`     | Only outputs the log message itself, useful when your logs are json and you want to pipe them to `jq` |
| `json`    | Marshals the log struct to json. Useful for programmatic purposes                                     |

It accepts a custom template through the `--template` flag, which will be
compiled to a Go template and then used for every log message. This Go template
will receive the following struct:

| property        | type   | description                                 |
|-----------------|--------|---------------------------------------------|
| `Message`       | string | The log message itself                      |
| `NodeName`      | string | The node name where the pod is scheduled on |
| `Namespace`     | string | The namespace of the pod                    |
| `PodName`       | string | The name of the pod                         |
| `ContainerName` | string | The name of the container                   |

The following functions are available within the template (besides the [builtin
functions](https://golang.org/pkg/text/template/#hdr-Functions)):

| func            | arguments             | description                                                                       |
|-----------------|-----------------------|-----------------------------------------------------------------------------------|
| `json`          | `object`              | Marshal the object and output it as a json text                                   |
| `color`         | `color.Color, string` | Wrap the text in color (.ContainerColor and .PodColor provided)                   |
| `parseJSON`     | `string`              | Parse string as JSON                                                              |
| `tryParseJSON`  | `string`              | Attempt to parse string as JSON, return nil on failure                             |
| `extractJSONParts`    | `string, ...string` | Parse string as JSON and concatenate the given keys.                          |
| `tryExtractJSONParts` | `string, ...string` | Attempt to parse string as JSON and concatenate the given keys. , return text on failure |
| `extjson`       | `string`              | Parse the object as json and output colorized json                                |
| `ppextjson`     | `string`              | Parse the object as json and output pretty-print colorized json                   |
| `toRFC3339Nano` | `object`              | Parse timestamp (string, int, json.Number) and output it using RFC3339Nano format |
| `toTimestamp`   | `object, string [, string]` | Parse timestamp (string, int, json.Number) and output it using the given layout in the timezone that is optionally given (defaults to UTC). |
| `levelColor`    | `string`              | Print log level using appropriate color                                           |
| `colorBlack`    | `string`              | Print text using black color                                                      |
| `colorRed`      | `string`              | Print text using red color                                                        |
| `colorGreen`    | `string`              | Print text using green color                                                      |
| `colorYellow`   | `string`              | Print text using yellow color                                                     |
| `colorBlue`     | `string`              | Print text using blue color                                                       |
| `colorMagenta`  | `string`              | Print text using magenta color                                                    |
| `colorCyan`     | `string`              | Print text using cyan color                                                       |
| `colorWhite`    | `string`              | Print text using white color                                                      |

### Log level verbosity

You can configure the log level verbosity by the `--verbosity` flag.
It is useful when you want to know how stern interacts with a Kubernetes API server in troubleshooting.

Increasing the verbosity increases the number of logs. `--verbosity 6` would be a good starting point.

### Max log requests

Stern has the maximum number of concurrent logs to request to prevent unintentional load to a cluster.
The number can be configured by the `--max-log-requests` flag.

The behavior and the default are different depending on the presence of the `--no-follow` flag.

The combination of `--max-log-requests 1` and `--no-follow` will be helpful if you want to show logs in order.

## Examples:
Tail all logs from all namespaces
```
stern . --all-namespaces
```

Tail the `kube-system` namespace without printing any prior logs
```
stern . -n kube-system --tail 0
```

Tail the `gateway` container running inside of the `envvars` pod on staging
```
stern envvars --context staging --container gateway
```

Tail the `staging` namespace excluding logs from `istio-proxy` container
```
stern -n staging --exclude-container istio-proxy .
```

Tail the `kube-system` namespace excluding logs from `kube-apiserver` pod
```
stern -n kube-system --exclude-pod kube-apiserver .
```

Show auth activity from 15min ago with timestamps
```
stern auth -t --since 15m
```

Show auth activity with timestamps in specific timezone (default is your local timezone)
```
stern auth -t --timezone Asia/Tokyo
```

Follow the development of `some-new-feature` in minikube
```
stern some-new-feature --context minikube
```

View pods from another namespace
```
stern kubernetes-dashboard --namespace kube-system
```

Tail the pods filtered by `run=nginx` label selector across all namespaces
```
stern --all-namespaces -l run=nginx
```

Follow the `frontend` pods in canary release
```
stern frontend --selector release=canary
```

Tail the pods on `kind-control-plane` node across all namespaces
```
stern --all-namespaces --field-selector spec.nodeName=kind-control-plane
```

Tail the pods created by `deployment/nginx`
```
stern deployment/nginx
```

Pipe the log message to jq:
```
stern backend -o json | jq .
```

Only output the log message itself:
```
stern backend -o raw
```

Output using a custom template:

```
stern --template '{{printf "%s (%s/%s/%s/%s)\n" .Message .NodeName .Namespace .PodName .ContainerName}}' backend
```

Output using a custom template with stern-provided colors:

```
stern --template '{{.Message}} ({{.Namespace}}/{{color .PodColor .PodName}}/{{color .ContainerColor .ContainerName}}){{"\n"}}' backend
```

Output using a custom template with `parseJSON`:

```
stern --template='{{.PodName}}/{{.ContainerName}} {{with $d := .Message | parseJSON}}[{{$d.level}}] {{$d.message}}{{end}}{{"\n"}}' backend
```

Output using a custom template that tries to parse JSON or fallbacks to raw format:

```
stern --template='{{.PodName}}/{{.ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano $msg.ts) }}] {{ levelColor $msg.level }} ({{ colorCyan $msg.caller }}) {{ $msg.msg }}{{ else }} {{ .Message }} {{ end }}{{"\n"}}' backend
```

Load custom template from file:

```
stern --template-file=~/.stern.tpl backend
```

Trigger the interactive prompt to select an 'app.kubernetes.io/instance' label value:

```
stern -p
```

Output log lines only:

```
stern . --only-log-lines
```

## Completion

Stern supports command-line auto completion for bash, zsh or fish. `stern
--completion=(bash|zsh|fish)` outputs the shell completion code which work by being
evaluated in `.bashrc`, etc for the specified shell. In addition, Stern
supports dynamic completion for `--namespace`, `--context`, `--node`, a resource query
in the form `<resource>/<name>`, and flags with pre-defined choices.

If you use bash, stern bash completion code depends on the
[bash-completion](https://github.com/scop/bash-completion). On the macOS, you
can install it with homebrew as follows:

```
# If running Bash 3.2
brew install bash-completion

# or, if running Bash 4.1+
brew install bash-completion@2
```

Note that bash-completion must be sourced before sourcing the stern bash
completion code in `.bashrc`.

```sh
source "$(brew --prefix)/etc/profile.d/bash_completion.sh"
source <(stern --completion=bash)
```

If installed via Krew, use:

```bash
source <(kubectl stern --completion bash)
complete -o default -F __start_stern kubectl stern
```

If you use zsh, just source the stern zsh completion code in `.zshrc`.

```sh
source <(stern --completion=zsh)
```

if you use fish shell, just source the stern fish completion code.

```sh
stern --completion=fish | source

# To load completions for each session, execute once:
stern --completion=fish >~/.config/fish/completions/stern.fish
```

## Running with container

You can also use stern using a container:

```
docker run ghcr.io/stern/stern --version
```

If you are using a minikube cluster, you need to run a container as follows:

```
docker run --rm -v "$HOME/.minikube:$HOME/.minikube" -v "$HOME/.kube:/$HOME/.kube" -e KUBECONFIG="$HOME/.kube/config" ghcr.io/stern/stern .
```

You can find image tags in https://github.com/orgs/stern/packages/container/package/stern.

## Running in Kubernetes Pods

If you want to use stern in Kubernetes Pods, you need to create the following ClusterRole and bind it to ServiceAccount.

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: stern
rules:
- apiGroups: [""]
  resources: ["pods", "pods/log"]
  verbs: ["get", "watch", "list"]
```

## Contributing to this repository

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.
07070100000012000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001100000000stern-1.28.0/cmd07070100000013000081A4000000000000000000000001659C91000000563C000000000000000000000000000000000000001800000000stern-1.28.0/cmd/cmd.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package cmd

import (
	"context"
	"encoding/json"
	goflag "flag"
	"fmt"
	"io"
	"os"
	"regexp"
	"strconv"
	"strings"
	"text/template"
	"time"

"github.com/fatih/color"
	"github.com/mitchellh/go-homedir"
	"github.com/pkg/errors"
	"github.com/spf13/cast"
	"github.com/spf13/cobra"
	"github.com/spf13/pflag"
	"github.com/stern/stern/stern"
	"gopkg.in/yaml.v3"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/cli-runtime/pkg/genericclioptions"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	"k8s.io/klog/v2"

// load all auth plugins
	_ "k8s.io/client-go/plugin/pkg/client/auth"
)

// Use "~" to avoid exposing the user name in the help message
var defaultConfigFilePath = "~/.config/stern/config.yaml"

type options struct {
	configFlags *genericclioptions.ConfigFlags
	genericclioptions.IOStreams

excludePod          []string
	container           string
	excludeContainer    []string
	containerStates     []string
	timestamps          string
	timezone            string
	since               time.Duration
	namespaces          []string
	exclude             []string
	include             []string
	highlight           []string
	initContainers      bool
	ephemeralContainers bool
	allNamespaces       bool
	selector            string
	fieldSelector       string
	tail                int64
	color               string
	version             bool
	completion          string
	template            string
	templateFile        string
	output              string
	prompt              bool
	podQuery            string
	noFollow            bool
	resource            string
	verbosity           int
	onlyLogLines        bool
	maxLogRequests      int
	node                string
	configFilePath      string
	showHiddenOptions   bool

client       kubernetes.Interface
	clientConfig clientcmd.ClientConfig
}

func NewOptions(streams genericclioptions.IOStreams) *options {
	configFlags := genericclioptions.NewConfigFlags(true)
	// stern has its own namespace flag, so disable the one in configFlags
	configFlags.Namespace = nil

return &options{
		configFlags: configFlags,
		IOStreams:   streams,

color:               "auto",
		container:           ".*",
		containerStates:     []string{stern.ALL_STATES},
		initContainers:      true,
		ephemeralContainers: true,
		output:              "default",
		since:               48 * time.Hour,
		tail:                -1,
		template:            "",
		templateFile:        "",
		timestamps:          "",
		timezone:            "Local",
		prompt:              false,
		noFollow:            false,
		maxLogRequests:      -1,
		configFilePath:      defaultConfigFilePath,
	}
}

func (o *options) Complete(args []string) error {
	if len(args) > 0 {
		if s := args[0]; strings.Contains(s, "/") {
			o.resource = s
		} else {
			o.podQuery = s
		}
	}

envVar, ok := os.LookupEnv("STERNCONFIG")
	if ok {
		o.configFilePath = envVar
	}

o.clientConfig = o.configFlags.ToRawKubeConfigLoader()

restConfig, err := o.configFlags.ToRESTConfig()
	if err != nil {
		return err
	}

o.client = kubernetes.NewForConfigOrDie(restConfig)

if len(o.namespaces) == 0 {
		namespace, _, err := o.clientConfig.Namespace()
		if err != nil {
			return err
		}
		o.namespaces = []string{namespace}
	}

return nil
}

func (o *options) Validate() error {
	if !o.prompt && o.podQuery == "" && o.resource == "" && o.selector == "" && o.fieldSelector == "" {
		return errors.New("One of pod-query, --selector, --field-selector or --prompt is required")
	}
	if o.selector != "" && o.resource != "" {
		return errors.New("--selector and the <resource>/<name> query can not be set at the same time")
	}

return nil
}

func (o *options) Run(cmd *cobra.Command) error {
	if err := o.setVerbosity(); err != nil {
		return err
	}

config, err := o.sternConfig()
	if err != nil {
		return err
	}

ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

if o.prompt {
		if err := promptHandler(ctx, o.client, config, o.Out); err != nil {
			return err
		}
	}

return stern.Run(ctx, o.client, config)
}

func (o *options) sternConfig() (*stern.Config, error) {
	pod, err := regexp.Compile(o.podQuery)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression from query")
	}

excludePod, err := compileREs(o.excludePod)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for excluded pod query")
	}

container, err := regexp.Compile(o.container)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for container query")
	}

excludeContainer, err := compileREs(o.excludeContainer)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for excluded container query")
	}

exclude, err := compileREs(o.exclude)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for exclusion filter")
	}

include, err := compileREs(o.include)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for inclusion filter")
	}

highlight, err := compileREs(o.highlight)
	if err != nil {
		return nil, errors.Wrap(err, "failed to compile regular expression for highlight filter")
	}

containerStates := []stern.ContainerState{}
	for _, containerStateStr := range makeUnique(o.containerStates) {
		containerState, err := stern.NewContainerState(containerStateStr)
		if err != nil {
			return nil, err
		}
		containerStates = append(containerStates, containerState)
	}

labelSelector := labels.Everything()
	if o.selector != "" {
		labelSelector, err = labels.Parse(o.selector)
		if err != nil {
			return nil, errors.Wrap(err, "failed to parse selector as label selector")
		}
	}

fieldSelector, err := o.generateFieldSelector()
	if err != nil {
		return nil, err
	}

var tailLines *int64
	if o.tail != -1 {
		tailLines = &o.tail
	}

switch o.color {
	case "always":
		color.NoColor = false
	case "never":
		color.NoColor = true
	case "auto":
	default:
		return nil, errors.New("color should be one of 'always', 'never', or 'auto'")
	}

template, err := o.generateTemplate()
	if err != nil {
		return nil, err
	}

namespaces := makeUnique(o.namespaces)

var timestampFormat string
	switch o.timestamps {
	case "default":
		timestampFormat = stern.TimestampFormatDefault
	case "short":
		timestampFormat = stern.TimestampFormatShort
	case "":
	default:
		return nil, errors.New("timestamps should be one of 'default', or 'short'")
	}

// --timezone
	location, err := time.LoadLocation(o.timezone)
	if err != nil {
		return nil, err
	}

maxLogRequests := o.maxLogRequests
	if maxLogRequests == -1 {
		if o.noFollow {
			maxLogRequests = 5
		} else {
			maxLogRequests = 50
		}
	}

return &stern.Config{
		Namespaces:            namespaces,
		PodQuery:              pod,
		ExcludePodQuery:       excludePod,
		Timestamps:            timestampFormat != "",
		TimestampFormat:       timestampFormat,
		Location:              location,
		ContainerQuery:        container,
		ExcludeContainerQuery: excludeContainer,
		ContainerStates:       containerStates,
		Exclude:               exclude,
		Include:               include,
		Highlight:             highlight,
		InitContainers:        o.initContainers,
		EphemeralContainers:   o.ephemeralContainers,
		Since:                 o.since,
		AllNamespaces:         o.allNamespaces,
		LabelSelector:         labelSelector,
		FieldSelector:         fieldSelector,
		TailLines:             tailLines,
		Template:              template,
		Follow:                !o.noFollow,
		Resource:              o.resource,
		OnlyLogLines:          o.onlyLogLines,
		MaxLogRequests:        maxLogRequests,

Out:    o.Out,
		ErrOut: o.ErrOut,
	}, nil
}

// setVerbosity sets the log level verbosity
func (o *options) setVerbosity() error {
	if o.verbosity != 0 {
		// klog does not have an external method to set verbosity,
		// so we need to set it by a flag.
		// See https://github.com/kubernetes/klog/issues/336 for details
		var fs goflag.FlagSet
		klog.InitFlags(&fs)
		return fs.Set("v", strconv.Itoa(o.verbosity))
	}
	return nil
}

// overrideFlagSetDefaultFromConfig overrides the default value of the flagSets
// from the config file
func (o *options) overrideFlagSetDefaultFromConfig(fs *pflag.FlagSet) error {
	expanded, err := homedir.Expand(o.configFilePath)
	if err != nil {
		return err
	}

if o.configFilePath == defaultConfigFilePath {
		if _, err := os.Stat(expanded); os.IsNotExist(err) {
			return nil
		}
	}

configFile, err := os.Open(expanded)
	if err != nil {
		return err
	}

data := make(map[string]interface{})

if err := yaml.NewDecoder(configFile).Decode(data); err != nil && err != io.EOF {
		return err
	}

for name, value := range data {
		flag := fs.Lookup(name)
		if flag == nil {
			// To avoid command execution failure, we only output a warning
			// message instead of exiting with an error if an unknown option is
			// specified.
			klog.Warningf("Unknown option specified in the config file: %s", name)
			continue
		}

// flag has higher priority than the config file
		if flag.Changed {
			continue
		}

if err := flag.Value.Set(fmt.Sprint(value)); err != nil {
			return fmt.Errorf("invalid value %q for %q in the config file: %v", value, name, err)
		}
	}

return nil
}

// AddFlags adds all the flags used by stern.
func (o *options) AddFlags(fs *pflag.FlagSet) {
	o.addKubernetesFlags(fs)

fs.BoolVarP(&o.allNamespaces, "all-namespaces", "A", o.allNamespaces, "If present, tail across all namespaces. A specific namespace is ignored even if specified with --namespace.")
	fs.StringVar(&o.color, "color", o.color, "Force set color output. 'auto':  colorize if tty attached, 'always': always colorize, 'never': never colorize.")
	fs.StringVar(&o.completion, "completion", o.completion, "Output stern command-line completion code for the specified shell. Can be 'bash', 'zsh' or 'fish'.")
	fs.StringVarP(&o.container, "container", "c", o.container, "Container name when multiple containers in pod. (regular expression)")
	fs.StringSliceVar(&o.containerStates, "container-state", o.containerStates, "Tail containers with state in running, waiting, terminated, or all. 'all' matches all container states. To specify multiple states, repeat this or set comma-separated value.")
	fs.StringArrayVarP(&o.exclude, "exclude", "e", o.exclude, "Log lines to exclude. (regular expression)")
	fs.StringArrayVarP(&o.excludeContainer, "exclude-container", "E", o.excludeContainer, "Container name to exclude when multiple containers in pod. (regular expression)")
	fs.StringArrayVar(&o.excludePod, "exclude-pod", o.excludePod, "Pod name to exclude. (regular expression)")
	fs.BoolVar(&o.noFollow, "no-follow", o.noFollow, "Exit when all logs have been shown.")
	fs.StringArrayVarP(&o.include, "include", "i", o.include, "Log lines to include. (regular expression)")
	fs.StringArrayVarP(&o.highlight, "highlight", "H", o.highlight, "Log lines to highlight. (regular expression)")
	fs.BoolVar(&o.initContainers, "init-containers", o.initContainers, "Include or exclude init containers.")
	fs.BoolVar(&o.ephemeralContainers, "ephemeral-containers", o.ephemeralContainers, "Include or exclude ephemeral containers.")
	fs.StringSliceVarP(&o.namespaces, "namespace", "n", o.namespaces, "Kubernetes namespace to use. Default to namespace configured in kubernetes context. To specify multiple namespaces, repeat this or set comma-separated value.")
	fs.StringVar(&o.node, "node", o.node, "Node name to filter on.")
	fs.IntVar(&o.maxLogRequests, "max-log-requests", o.maxLogRequests, "Maximum number of concurrent logs to request. Defaults to 50, but 5 when specifying --no-follow")
	fs.StringVarP(&o.output, "output", "o", o.output, "Specify predefined template. Currently support: [default, raw, json, extjson, ppextjson]")
	fs.BoolVarP(&o.prompt, "prompt", "p", o.prompt, "Toggle interactive prompt for selecting 'app.kubernetes.io/instance' label values.")
	fs.StringVarP(&o.selector, "selector", "l", o.selector, "Selector (label query) to filter on. If present, default to \".*\" for the pod-query.")
	fs.StringVar(&o.fieldSelector, "field-selector", o.fieldSelector, "Selector (field query) to filter on. If present, default to \".*\" for the pod-query.")
	fs.DurationVarP(&o.since, "since", "s", o.since, "Return logs newer than a relative duration like 5s, 2m, or 3h.")
	fs.Int64Var(&o.tail, "tail", o.tail, "The number of lines from the end of the logs to show. Defaults to -1, showing all logs.")
	fs.StringVar(&o.template, "template", o.template, "Template to use for log lines, leave empty to use --output flag.")
	fs.StringVarP(&o.templateFile, "template-file", "T", o.templateFile, "Path to template to use for log lines, leave empty to use --output flag. It overrides --template option.")
	fs.StringVarP(&o.timestamps, "timestamps", "t", o.timestamps, "Print timestamps with the specified format. One of 'default' or 'short'. If specified but without value, 'default' is used.")
	fs.StringVar(&o.timezone, "timezone", o.timezone, "Set timestamps to specific timezone.")
	fs.BoolVar(&o.onlyLogLines, "only-log-lines", o.onlyLogLines, "Print only log lines")
	fs.StringVar(&o.configFilePath, "config", o.configFilePath, "Path to the stern config file")
	fs.IntVar(&o.verbosity, "verbosity", o.verbosity, "Number of the log level verbosity")
	fs.BoolVarP(&o.version, "version", "v", o.version, "Print the version and exit.")
	fs.BoolVar(&o.showHiddenOptions, "show-hidden-options", o.showHiddenOptions, "Print a list of hidden options.")

fs.Lookup("timestamps").NoOptDefVal = "default"
}

func (o *options) addKubernetesFlags(fs *pflag.FlagSet) {
	flagset := pflag.NewFlagSet("", pflag.ExitOnError)
	o.configFlags.AddFlags(flagset)
	flagset.VisitAll(func(f *pflag.Flag) {
		// Hide Kubernetes flags except some
		if !(f.Name == "kubeconfig" || f.Name == "context") {
			f.Hidden = true
		}

// `server` flag in configFlags has `s` shorthand, which is used by stern
		// as shorthand for `since` flag, so do not use it.
		if f.Name == "server" {
			f.Shorthand = ""
		}
	})
	fs.AddFlagSet(flagset)
}

func (o *options) outputHiddenOptions() {
	fs := pflag.NewFlagSet("", pflag.ExitOnError)
	o.AddFlags(fs)
	fs.VisitAll(func(f *pflag.Flag) {
		f.Hidden = !f.Hidden
	})
	fmt.Println("The following options can also be used in stern:")
	fs.PrintDefaults()
}

func (o *options) generateTemplate() (*template.Template, error) {
	t := o.template
	if o.templateFile != "" {
		data, err := os.ReadFile(o.templateFile)
		if err != nil {
			return nil, err
		}
		t = string(data)
	}
	if t == "" {
		switch o.output {
		case "default":
			t = "{{color .PodColor .PodName}} {{color .ContainerColor .ContainerName}} {{.Message}}"
			if o.allNamespaces || len(o.namespaces) > 1 {
				t = fmt.Sprintf("{{color .PodColor .Namespace}} %s", t)
			}
		case "raw":
			t = "{{.Message}}"
		case "json":
			t = "{{json .}}"
		case "extjson":
			t = "\"pod\": \"{{color .PodColor .PodName}}\", \"container\": \"{{color .ContainerColor .ContainerName}}\", \"message\": {{extjson .Message}}"
			if o.allNamespaces {
				t = fmt.Sprintf("\"namespace\": \"{{color .PodColor .Namespace}}\", %s", t)
			}
			t = fmt.Sprintf("{%s}", t)
		case "ppextjson":
			t = "  \"pod\": \"{{color .PodColor .PodName}}\",\n  \"container\": \"{{color .ContainerColor .ContainerName}}\",\n  \"message\": {{extjson .Message}}"
			if o.allNamespaces {
				t = fmt.Sprintf("  \"namespace\": \"{{color .PodColor .Namespace}}\",\n%s", t)
			}
			t = fmt.Sprintf("{\n%s\n}", t)
		default:
			return nil, errors.New("output should be one of 'default', 'raw', 'json', 'extjson', and 'ppextjson'")
		}
		t += "\n"
	}

funs := map[string]interface{}{
		"json": func(in interface{}) (string, error) {
			b, err := json.Marshal(in)
			if err != nil {
				return "", err
			}
			return string(b), nil
		},
		"tryParseJSON": func(text string) map[string]interface{} {
			decoder := json.NewDecoder(strings.NewReader(text))
			decoder.UseNumber()
			obj := make(map[string]interface{})
			if err := decoder.Decode(&obj); err != nil {
				return nil
			}
			return obj
		},
		"parseJSON": func(text string) (map[string]interface{}, error) {
			obj := make(map[string]interface{})
			if err := json.Unmarshal([]byte(text), &obj); err != nil {
				return obj, err
			}
			return obj, nil
		},
		"extractJSONParts": func(text string, part ...string) (string, error) {
			obj := make(map[string]interface{})
			if err := json.Unmarshal([]byte(text), &obj); err != nil {
				return "", err
			}
			parts := make([]string, 0)
			for _, key := range part {
				parts = append(parts, fmt.Sprintf("%v", obj[key]))
			}
			return strings.Join(parts, ", "), nil
		},
		"tryExtractJSONParts": func(text string, part ...string) string {
			obj := make(map[string]interface{})
			if err := json.Unmarshal([]byte(text), &obj); err != nil {
				return text
			}
			parts := make([]string, 0)
			for _, key := range part {
				parts = append(parts, fmt.Sprintf("%v", obj[key]))
			}
			return strings.Join(parts, ", ")
		},
		"extjson": func(in string) (string, error) {
			if json.Valid([]byte(in)) {
				return strings.TrimSuffix(in, "\n"), nil
			}
			b, err := json.Marshal(in)
			if err != nil {
				return "", err
			}
			return strings.TrimSuffix(string(b), "\n"), nil
		},
		"toRFC3339Nano": func(ts any) string {
			return cast.ToTime(ts).Format(time.RFC3339Nano)
		},
		"toUTC": func(ts any) time.Time {
			return cast.ToTime(ts).UTC()
		},
		"toTimestamp": func(ts any, layout string, optionalTZ ...string) (string, error) {
			t, parseErr := cast.ToTimeE(ts)
			if parseErr != nil {
				return "", parseErr
			}

var tz string
			if len(optionalTZ) > 0 {
				tz = optionalTZ[0]
			}

loc, loadErr := time.LoadLocation(tz)
			if loadErr != nil {
				return "", loadErr
			}

return t.In(loc).Format(layout), nil
		},
		"color": func(color color.Color, text string) string {
			return color.SprintFunc()(text)
		},
		"colorBlack":   color.BlackString,
		"colorRed":     color.RedString,
		"colorGreen":   color.GreenString,
		"colorYellow":  color.YellowString,
		"colorBlue":    color.BlueString,
		"colorMagenta": color.MagentaString,
		"colorCyan":    color.CyanString,
		"colorWhite":   color.WhiteString,
		"levelColor": func(level string) string {
			var levelColor *color.Color
			switch strings.ToLower(level) {
			case "debug":
				levelColor = color.New(color.FgMagenta)
			case "info":
				levelColor = color.New(color.FgBlue)
			case "warn":
				levelColor = color.New(color.FgYellow)
			case "warning":
				levelColor = color.New(color.FgYellow)
			case "error":
				levelColor = color.New(color.FgRed)
			case "dpanic":
				levelColor = color.New(color.FgRed)
			case "panic":
				levelColor = color.New(color.FgRed)
			case "fatal":
				levelColor = color.New(color.FgCyan)
			case "critical":
				levelColor = color.New(color.FgCyan)
			default:
				return level
			}
			return levelColor.SprintFunc()(level)
		},
	}
	template, err := template.New("log").Funcs(funs).Parse(t)
	if err != nil {
		return nil, errors.Wrap(err, "unable to parse template")
	}
	return template, err
}

func (o *options) generateFieldSelector() (fields.Selector, error) {
	var queries []string
	if o.fieldSelector != "" {
		queries = append(queries, o.fieldSelector)
	}
	if o.node != "" {
		queries = append(queries, fmt.Sprintf("spec.nodeName=%s", o.node))
	}
	if len(queries) == 0 {
		return fields.Everything(), nil
	}

fieldSelector, err := fields.ParseSelector(strings.Join(queries, ","))
	if err != nil {
		return nil, errors.Wrap(err, "failed to parse selector as field selector")
	}
	return fieldSelector, nil
}

func NewSternCmd(stream genericclioptions.IOStreams) (*cobra.Command, error) {
	o := NewOptions(stream)

cmd := &cobra.Command{
		Use:   "stern pod-query",
		Short: "Tail multiple pods and containers from Kubernetes",
		RunE: func(cmd *cobra.Command, args []string) error {
			// Output version information and exit
			if o.version {
				outputVersionInfo(o.Out)
				return nil
			}

// Output shell completion code for the specified shell and exit
			if o.completion != "" {
				return runCompletion(o.completion, cmd, o.Out)
			}

if o.showHiddenOptions {
				o.outputHiddenOptions()
				return nil
			}

if err := o.Complete(args); err != nil {
				return err
			}

if err := o.overrideFlagSetDefaultFromConfig(cmd.Flags()); err != nil {
				return err
			}

if err := o.Validate(); err != nil {
				return err
			}

cmd.SilenceUsage = true

return o.Run(cmd)
		},
		ValidArgsFunction: queryCompletionFunc(o),
	}

cmd.SetUsageTemplate(cmd.UsageTemplate() + "\nUse \"stern --show-hidden-options\" for a list of hidden command-line options.\n")

o.AddFlags(cmd.Flags())

if err := registerCompletionFuncForFlags(cmd, o); err != nil {
		return cmd, err
	}

return cmd, nil
}

// makeUnique makes items in string slice unique
func makeUnique(items []string) []string {
	result := []string{}
	m := make(map[string]struct{})

for _, item := range items {
		if item == "" {
			continue
		}

if _, ok := m[item]; !ok {
			m[item] = struct{}{}
			result = append(result, item)
		}
	}

return result
}

func compileREs(exprs []string) ([]*regexp.Regexp, error) {
	var regexps []*regexp.Regexp
	for _, s := range exprs {
		re, err := regexp.Compile(s)
		if err != nil {
			return nil, err
		}
		regexps = append(regexps, re)
	}
	return regexps, nil
}
07070100000014000081A4000000000000000000000001659C910000004BBA000000000000000000000000000000000000001D00000000stern-1.28.0/cmd/cmd_test.gopackage cmd

import (
	"bytes"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strings"
	"testing"
	"time"

"github.com/fatih/color"
	"github.com/spf13/pflag"
	"github.com/stern/stern/stern"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/cli-runtime/pkg/genericclioptions"
	"k8s.io/utils/ptr"
)

func TestSternCommand(t *testing.T) {
	tests := []struct {
		name string
		args []string
		out  string
	}{
		{
			"Output version info with --version",
			[]string{"--version"},
			"version: dev",
		},
		{
			"Output completion code for bash with --completion=bash",
			[]string{"--completion=bash"},
			"complete -o default -F __start_stern stern",
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			streams, _, out, _ := genericclioptions.NewTestIOStreams()
			stern, err := NewSternCmd(streams)
			if err != nil {
				t.Fatal(err)
			}
			stern.SetArgs(tt.args)

if err := stern.Execute(); err != nil {
				t.Fatal(err)
			}

if !strings.Contains(out.String(), tt.out) {
				t.Errorf("expected to contain %s, but actual %s", tt.out, out.String())
			}
		})
	}
}

func TestOptionsComplete(t *testing.T) {
	streams := genericclioptions.NewTestIOStreamsDiscard()

tests := []struct {
		name                   string
		env                    map[string]string
		args                   []string
		expectedConfigFilePath string
	}{
		{
			name:                   "No environment variables",
			env:                    map[string]string{},
			args:                   []string{},
			expectedConfigFilePath: defaultConfigFilePath,
		},
		{
			name: "Set STERNCONFIG env to ./config.yaml",
			env: map[string]string{
				"STERNCONFIG": "./config.yaml",
			},
			args:                   []string{},
			expectedConfigFilePath: "./config.yaml",
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			for k, v := range tt.env {
				t.Setenv(k, v)
			}

o := NewOptions(streams)
			_ = o.Complete(tt.args)

if tt.expectedConfigFilePath != o.configFilePath {
				t.Errorf("expected %s for configFilePath, but got %s", tt.expectedConfigFilePath, o.configFilePath)
			}
		})
	}
}

func TestOptionsValidate(t *testing.T) {
	streams := genericclioptions.NewTestIOStreamsDiscard()

tests := []struct {
		name string
		o    *options
		err  string
	}{
		{
			"No required options",
			NewOptions(streams),
			"One of pod-query, --selector, --field-selector or --prompt is required",
		},
		{
			"Specify both selector and resource",
			func() *options {
				o := NewOptions(streams)
				o.selector = "app=nginx"
				o.resource = "deployment/nginx"

return o
			}(),
			"--selector and the <resource>/<name> query can not be set at the same time",
		},
		{
			"Use prompt",
			func() *options {
				o := NewOptions(streams)
				o.prompt = true

return o
			}(),
			"",
		},
		{
			"Specify pod-query",
			func() *options {
				o := NewOptions(streams)
				o.podQuery = "."

return o
			}(),
			"",
		},
		{
			"Specify selector",
			func() *options {
				o := NewOptions(streams)
				o.selector = "app=nginx"

return o
			}(),
			"",
		},
		{
			"Specify fieldSelector",
			func() *options {
				o := NewOptions(streams)
				o.fieldSelector = "spec.nodeName=kind-kind"

return o
			}(),
			"",
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := tt.o.Validate()
			if err == nil {
				if tt.err != "" {
					t.Errorf("expected %q err, but actual no err", tt.err)
				}
			} else {
				if tt.err != err.Error() {
					t.Errorf("expected %q err, but actual %q", tt.err, err)
				}
			}
		})
	}
}

func TestOptionsGenerateTemplate(t *testing.T) {
	t.Setenv("NO_COLOR", "1")
	streams := genericclioptions.NewTestIOStreamsDiscard()

tests := []struct {
		name      string
		o         *options
		message   string
		want      string
		wantError bool
	}{
		{
			"output=default",
			func() *options {
				o := NewOptions(streams)
				o.output = "default"

return o
			}(),
			"default message",
			"pod1 container1 default message\n",
			false,
		},
		{
			"output=default+allNamespaces",
			func() *options {
				o := NewOptions(streams)
				o.output = "default"
				o.allNamespaces = true

return o
			}(),
			"default message",
			"ns1 pod1 container1 default message\n",
			false,
		},
		{
			"output=raw",
			func() *options {
				o := NewOptions(streams)
				o.output = "raw"

return o
			}(),
			"raw message",
			"raw message\n",
			false,
		},
		{
			"output=json",
			func() *options {
				o := NewOptions(streams)
				o.output = "json"

return o
			}(),
			"json message",
			`{"message":"json message","nodeName":"node1","namespace":"ns1","podName":"pod1","containerName":"container1"}
`,
			false,
		},
		{
			"output=extjson",
			func() *options {
				o := NewOptions(streams)
				o.output = "extjson"

return o
			}(),
			`{"msg":"extjson message"}`,
			`{"pod": "pod1", "container": "container1", "message": {"msg":"extjson message"}}
`,
			false,
		},
		{
			"output=extjson+allNamespaces",
			func() *options {
				o := NewOptions(streams)
				o.output = "extjson"
				o.allNamespaces = true

return o
			}(),
			`{"msg":"extjson message"}`,
			`{"namespace": "ns1", "pod": "pod1", "container": "container1", "message": {"msg":"extjson message"}}
`,
			false,
		},
		{
			"output=ppextjson",
			func() *options {
				o := NewOptions(streams)
				o.output = "ppextjson"

return o
			}(),
			`{"msg":"ppextjson message"}`,
			`{
  "pod": "pod1",
  "container": "container1",
  "message": {"msg":"ppextjson message"}
}
`,
			false,
		},
		{
			"output=ppextjson+allNamespaces",
			func() *options {
				o := NewOptions(streams)
				o.output = "ppextjson"
				o.allNamespaces = true

return o
			}(),
			`{"msg":"ppextjson message"}`,
			`{
  "namespace": "ns1",
  "pod": "pod1",
  "container": "container1",
  "message": {"msg":"ppextjson message"}
}
`,
			false,
		},
		{
			"invalid output",
			func() *options {
				o := NewOptions(streams)
				o.output = "invalid"

return o
			}(),
			"message",
			"",
			true,
		},
		{
			"template",
			func() *options {
				o := NewOptions(streams)
				o.template = "Message={{.Message}} NodeName={{.NodeName}} Namespace={{.Namespace}} PodName={{.PodName}} ContainerName={{.ContainerName}}"

return o
			}(),
			"template message", // no new line
			"Message=template message NodeName=node1 Namespace=ns1 PodName=pod1 ContainerName=container1",
			false,
		},
		{
			"invalid template",
			func() *options {
				o := NewOptions(streams)
				o.template = "{{invalid"

return o
			}(),
			"template message",
			"",
			true,
		},
		{
			"template-file",
			func() *options {
				o := NewOptions(streams)
				o.templateFile = "test.tpl"

return o
			}(),
			"template message",
			"pod1 container1 template message",
			false,
		},
		{
			"template-file-json-log-ts-float",
			func() *options {
				o := NewOptions(streams)
				o.templateFile = "test.tpl"

return o
			}(),
			`{"ts": 123, "level": "INFO", "msg": "template message"}`,
			"pod1 container1 [1970-01-01T00:02:03Z] INFO template message",
			false,
		},
		{
			"template-file-json-log-ts-str",
			func() *options {
				o := NewOptions(streams)
				o.templateFile = "test.tpl"

return o
			}(),
			`{"ts": "1970-01-01T01:02:03+01:00", "level": "INFO", "msg": "template message"}`,
			"pod1 container1 [1970-01-01T00:02:03Z] INFO template message",
			false,
		},
		{
			"template-to-timestamp-with-timezone",
			func() *options {
				o := NewOptions(streams)
				o.template = `{{ toTimestamp .Message "Jan 02 2006 15:04 MST" "US/Eastern" }}`
				return o
			}(),
			`2024-01-01T05:00:00`,
			`Jan 01 2024 00:00 EST`,
			false,
		},
		{
			"template-to-timestamp-without-timezone",
			func() *options {
				o := NewOptions(streams)
				o.template = `{{ toTimestamp .Message "Jan 02 2006 15:04 MST" }}`
				return o
			}(),
			`2024-01-01T05:00:00`,
			`Jan 01 2024 05:00 UTC`,
			false,
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			log := stern.Log{
				Message:        tt.message,
				NodeName:       "node1",
				Namespace:      "ns1",
				PodName:        "pod1",
				ContainerName:  "container1",
				PodColor:       color.New(color.FgRed),
				ContainerColor: color.New(color.FgBlue),
			}
			tmpl, err := tt.o.generateTemplate()

if tt.wantError {
				if err == nil {
					t.Errorf("expected error, but got no error")
				}
				return
			}
			if err != nil {
				t.Errorf("unexpected error: %v", err)
				return
			}

var buf bytes.Buffer
			if err := tmpl.Execute(&buf, log); err != nil {
				t.Errorf("unexpected error: %v", err)
				return
			}
			if want, got := tt.want, buf.String(); want != got {
				t.Errorf("want %v, but got %v", want, got)
			}
		})
	}
}

func TestOptionsSternConfig(t *testing.T) {
	streams := genericclioptions.NewTestIOStreamsDiscard()

local, _ := time.LoadLocation("Local")
	utc, _ := time.LoadLocation("UTC")
	labelSelector, _ := labels.Parse("l=sel")
	fieldSelector, _ := fields.ParseSelector("f=field,spec.nodeName=node1")

re := regexp.MustCompile

defaultConfig := func() *stern.Config {
		return &stern.Config{
			Namespaces:            []string{},
			PodQuery:              re(""),
			ExcludePodQuery:       nil,
			Timestamps:            false,
			TimestampFormat:       "",
			Location:              local,
			ContainerQuery:        re(".*"),
			ExcludeContainerQuery: nil,
			ContainerStates:       []stern.ContainerState{stern.ALL_STATES},
			Exclude:               nil,
			Include:               nil,
			Highlight:             nil,
			InitContainers:        true,
			EphemeralContainers:   true,
			Since:                 48 * time.Hour,
			AllNamespaces:         false,
			LabelSelector:         labels.Everything(),
			FieldSelector:         fields.Everything(),
			TailLines:             nil,
			Template:              nil, // ignore when comparing
			Follow:                true,
			Resource:              "",
			OnlyLogLines:          false,
			MaxLogRequests:        50,

Out:    streams.Out,
			ErrOut: streams.ErrOut,
		}
	}

tests := []struct {
		name      string
		o         *options
		want      *stern.Config
		wantError bool
	}{
		{
			"default",
			NewOptions(streams),
			defaultConfig(),
			false,
		},
		{
			"change all options",
			func() *options {
				o := NewOptions(streams)
				o.namespaces = []string{"ns1", "ns2"}
				o.podQuery = "query1"
				o.excludePod = []string{"exp1", "exp2"}
				o.timestamps = "default"
				o.timezone = "UTC" // Location
				o.container = "container1"
				o.excludeContainer = []string{"exc1", "exc2"}
				o.containerStates = []string{"running", "terminated"}
				o.exclude = []string{"ex1", "ex2"}
				o.include = []string{"in1", "in2"}
				o.highlight = []string{"hi1", "hi2"}
				o.initContainers = false
				o.ephemeralContainers = false
				o.since = 1 * time.Hour
				o.allNamespaces = true
				o.selector = "l=sel"
				o.fieldSelector = "f=field"
				o.tail = 10
				o.noFollow = true // Follow = false
				o.maxLogRequests = 30
				o.resource = "res1"
				o.onlyLogLines = true
				o.node = "node1"

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				c.Namespaces = []string{"ns1", "ns2"}
				c.PodQuery = re("query1")
				c.ExcludePodQuery = []*regexp.Regexp{re("exp1"), re("exp2")}
				c.Timestamps = true
				c.TimestampFormat = stern.TimestampFormatDefault
				c.Location = utc
				c.ContainerQuery = re("container1")
				c.ExcludeContainerQuery = []*regexp.Regexp{re("exc1"), re("exc2")}
				c.ContainerStates = []stern.ContainerState{stern.RUNNING, stern.TERMINATED}
				c.Exclude = []*regexp.Regexp{re("ex1"), re("ex2")}
				c.Include = []*regexp.Regexp{re("in1"), re("in2")}
				c.Highlight = []*regexp.Regexp{re("hi1"), re("hi2")}
				c.InitContainers = false
				c.EphemeralContainers = false
				c.Since = 1 * time.Hour
				c.AllNamespaces = true
				c.LabelSelector = labelSelector
				c.FieldSelector = fieldSelector
				c.TailLines = ptr.To[int64](10)
				c.Follow = false
				c.Resource = "res1"
				c.OnlyLogLines = true
				c.MaxLogRequests = 30

return c
			}(),
			false,
		},
		{
			"fieldSelector without node",
			func() *options {
				o := NewOptions(streams)
				o.fieldSelector = "f=field"

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				sel, _ := fields.ParseSelector("f=field")
				c.FieldSelector = sel

return c
			}(),
			false,
		},
		{
			"node without fieldSelector",
			func() *options {
				o := NewOptions(streams)
				o.node = "node1"

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				sel, _ := fields.ParseSelector("spec.nodeName=node1")
				c.FieldSelector = sel

return c
			}(),
			false,
		},
		{
			"timestamp=short",
			func() *options {
				o := NewOptions(streams)
				o.timestamps = "short"

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				c.Timestamps = true
				c.TimestampFormat = stern.TimestampFormatShort

return c
			}(),
			false,
		},
		{
			"noFollow has the different default",
			func() *options {
				o := NewOptions(streams)
				o.noFollow = true // Follow = false

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				c.Follow = false
				c.MaxLogRequests = 5 // default of noFollow

return c
			}(),
			false,
		},
		{
			"nil should be allowed",
			func() *options {
				o := NewOptions(streams)
				o.excludePod = nil
				o.excludeContainer = nil
				o.containerStates = nil
				o.namespaces = nil
				o.exclude = nil
				o.include = nil
				o.highlight = nil

return o
			}(),
			func() *stern.Config {
				c := defaultConfig()
				c.ContainerStates = []stern.ContainerState{}

return c
			}(),
			false,
		},
		{
			"error podQuery",
			func() *options {
				o := NewOptions(streams)
				o.podQuery = "[invalid"

return o
			}(),
			nil,
			true,
		},
		{
			"error excludePod",
			func() *options {
				o := NewOptions(streams)
				o.excludePod = []string{"exp1", "[invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error container",
			func() *options {
				o := NewOptions(streams)
				o.container = "[invalid"

return o
			}(),
			nil,
			true,
		},
		{
			"error excludeContainer",
			func() *options {
				o := NewOptions(streams)
				o.excludeContainer = []string{"exc1", "[invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error exclude",
			func() *options {
				o := NewOptions(streams)
				o.exclude = []string{"ex1", "[invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error include",
			func() *options {
				o := NewOptions(streams)
				o.include = []string{"in1", "[invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error highlight",
			func() *options {
				o := NewOptions(streams)
				o.highlight = []string{"hi1", "[invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error containerStates",
			func() *options {
				o := NewOptions(streams)
				o.containerStates = []string{"running", "invalid"}

return o
			}(),
			nil,
			true,
		},
		{
			"error selector",
			func() *options {
				o := NewOptions(streams)
				o.selector = "-"

return o
			}(),
			nil,
			true,
		},
		{
			"error fieldSelector",
			func() *options {
				o := NewOptions(streams)
				o.fieldSelector = "-"

return o
			}(),
			nil,
			true,
		},
		{
			"error color",
			func() *options {
				o := NewOptions(streams)
				o.color = "invalid"

return o
			}(),
			nil,
			true,
		},
		{
			"error output",
			func() *options {
				o := NewOptions(streams)
				o.output = "invalid"

return o
			}(),
			nil,
			true,
		},
		{
			"error timezone",
			func() *options {
				o := NewOptions(streams)
				o.timezone = "invalid"

return o
			}(),
			nil,
			true,
		},
		{
			"error timestamps",
			func() *options {
				o := NewOptions(streams)
				o.timestamps = "invalid"

return o
			}(),
			nil,
			true,
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := tt.o.sternConfig()
			if tt.wantError {
				if err == nil {
					t.Errorf("expected error, but got no error")
				}
				return
			}
			if err != nil {
				t.Errorf("unexpected error: %v", err)
				return
			}

// We skip the template as it is difficult to check
			// and is tested in TestOptionsGenerateTemplate().
			got.Template = nil

if !reflect.DeepEqual(tt.want, got) {
				t.Errorf("want %+v, but got %+v", tt.want, got)
			}
		})
	}
}

func TestOptionsOverrideFlagSetDefaultFromConfig(t *testing.T) {
	orig := defaultConfigFilePath
	defer func() {
		defaultConfigFilePath = orig
	}()

defaultConfigFilePath = "./config.yaml"
	wd, _ := os.Getwd()

tests := []struct {
		name                    string
		flagConfigFilePathValue string
		flagTailValue           string
		expectedTailValue       int64
		wantErr                 bool
	}{
		{
			name:                    "--config=testdata/config-tail1.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-tail1.yaml"),
			expectedTailValue:       1,
			wantErr:                 false,
		},
		{
			name:                    "--config=testdata/config-empty.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-empty.yaml"),
			expectedTailValue:       -1,
			wantErr:                 false,
		},
		{
			name:                    "--config=config-not-exist.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "config-not-exist.yaml"),
			wantErr:                 true,
		},
		{
			name:                    "--config=config-invalid.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-invalid.yaml"),
			wantErr:                 true,
		},
		{
			name:                    "--config=config-unknown-option.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-unknown-option.yaml"),
			expectedTailValue:       1,
			wantErr:                 false,
		},
		{
			name:                    "--config=config-tail-invalid-value.yaml",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-tail-invalid-value.yaml"),
			wantErr:                 true,
		},
		{
			name:              "config file path is not specified and config file does not exist",
			expectedTailValue: -1,
			wantErr:           false,
		},
		{
			name:                    "--config=testdata/config-tail1.yaml and --tail=2",
			flagConfigFilePathValue: filepath.Join(wd, "testdata/config-tail1.yaml"),
			flagTailValue:           "2",
			expectedTailValue:       2,
			wantErr:                 false,
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			o := NewOptions(genericclioptions.NewTestIOStreamsDiscard())
			fs := pflag.NewFlagSet("", pflag.ExitOnError)
			o.AddFlags(fs)

args := []string{}
			if tt.flagConfigFilePathValue != "" {
				args = append(args, "--config="+tt.flagConfigFilePathValue)
			}
			if tt.flagTailValue != "" {
				args = append(args, "--tail="+tt.flagTailValue)
			}

if err := fs.Parse(args); err != nil {
				t.Fatal(err)
			}

err := o.overrideFlagSetDefaultFromConfig(fs)
			if tt.wantErr {
				if err == nil {
					t.Error("expected err, but got nil")
				}
				return
			}

if err != nil {
				t.Errorf("unexpected err: %v", err)
			}

if tt.expectedTailValue != o.tail {
				t.Errorf("expected %d for tail, but got %d", tt.expectedTailValue, o.tail)
			}
		})
	}
}
07070100000015000081A4000000000000000000000001659C91000000232C000000000000000000000000000000000000002400000000stern-1.28.0/cmd/flag_completion.go//   Copyright 2017 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package cmd

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"strings"

"github.com/pkg/errors"
	"github.com/spf13/cobra"
	"github.com/stern/stern/stern"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
)

var flagChoices = map[string][]string{
	"color":           {"always", "never", "auto"},
	"completion":      {"bash", "zsh", "fish"},
	"container-state": {stern.RUNNING, stern.WAITING, stern.TERMINATED, stern.ALL_STATES},
	"output":          {"default", "raw", "json", "extjson", "ppextjson"},
	"timestamps":      {"default", "short"},
}

func runCompletion(shell string, cmd *cobra.Command, out io.Writer) error {
	var err error

switch shell {
	case "bash":
		err = cmd.GenBashCompletion(out)
	case "zsh":
		err = runCompletionZsh(cmd, out)
	case "fish":
		err = cmd.GenFishCompletion(out, true)
	default:
		err = fmt.Errorf("Unsupported shell type: %q", shell)
	}

return err
}

// runCompletionZsh is based on `kubectl completion zsh`. This function should
// be replaced by cobra implementation when cobra itself supports zsh completion.
// https://github.com/kubernetes/kubernetes/blob/v1.6.1/pkg/kubectl/cmd/completion.go#L136
func runCompletionZsh(cmd *cobra.Command, out io.Writer) error {
	b := new(bytes.Buffer)
	if err := cmd.GenZshCompletion(b); err != nil {
		return err
	}

// Cobra doesn't source zsh completion file, explicitly doing it here
	fmt.Fprintf(b, "compdef _stern stern")

fmt.Fprint(out, b.String())

return nil
}

func registerCompletionFuncForFlags(cmd *cobra.Command, o *options) error {
	if err := cmd.RegisterFlagCompletionFunc("namespace", namespaceCompletionFunc(o)); err != nil {
		return err
	}

if err := cmd.RegisterFlagCompletionFunc("node", nodeCompletionFunc(o)); err != nil {
		return err
	}

if err := cmd.RegisterFlagCompletionFunc("context", contextCompletionFunc(o)); err != nil {
		return err
	}

// flags with pre-defined choices
	for flag, choices := range flagChoices {
		if err := cmd.RegisterFlagCompletionFunc(flag,
			cobra.FixedCompletions(choices, cobra.ShellCompDirectiveNoFileComp)); err != nil {
			return err
		}
	}

return nil
}

// namespaceCompletionFunc is a completion function that completes namespaces
// that match the toComplete prefix.
func namespaceCompletionFunc(o *options) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
	return func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if err := o.Complete(nil); err != nil {
			return compError(err)
		}

namespaceList, err := o.client.CoreV1().Namespaces().List(context.TODO(), metav1.ListOptions{})
		if err != nil {
			return compError(err)
		}

var comps []string
		for _, ns := range namespaceList.Items {
			if strings.HasPrefix(ns.GetName(), toComplete) {
				comps = append(comps, ns.GetName())
			}
		}

return comps, cobra.ShellCompDirectiveNoFileComp
	}
}

// nodeCompletionFunc is a completion function that completes node names
// that match the toComplete prefix.
func nodeCompletionFunc(o *options) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
	return func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if err := o.Complete(nil); err != nil {
			return compError(err)
		}

nodeList, err := o.client.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
		if err != nil {
			return compError(err)
		}

var comps []string
		for _, node := range nodeList.Items {
			if strings.HasPrefix(node.GetName(), toComplete) {
				comps = append(comps, node.GetName())
			}
		}

return comps, cobra.ShellCompDirectiveNoFileComp
	}
}

// contextCompletionFunc is a completion function that completes contexts
// that match the toComplete prefix.
func contextCompletionFunc(o *options) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
	return func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if err := o.Complete(nil); err != nil {
			return compError(err)
		}

var comps []string
		kubeConfig, err := o.clientConfig.RawConfig()
		if err != nil {
			return compError(err)
		}
		for name := range kubeConfig.Contexts {
			if strings.HasPrefix(name, toComplete) {
				comps = append(comps, name)
			}
		}

return comps, cobra.ShellCompDirectiveNoFileComp
	}
}

// queryCompletionFunc is a completion function that completes a resource
// that match the toComplete prefix.
func queryCompletionFunc(o *options) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
	return func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if err := o.Complete(nil); err != nil {
			return compError(err)
		}

var comps []string
		parts := strings.Split(toComplete, "/")
		if len(parts) != 2 {
			// list available resources in the form "<resource>/"
			for _, matcher := range stern.ResourceMatchers {
				if strings.HasPrefix(matcher.Name(), toComplete) {
					comps = append(comps, matcher.Name()+"/")
				}
			}
			return comps, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
		}

// list available names in the resources in the form "<resource>/<name>"
		uniqueNamespaces := makeUnique(o.namespaces)
		if o.allNamespaces || len(uniqueNamespaces) > 1 {
			// do not support multiple namespaces for simplicity
			return compError(errors.New("multiple namespaces are not supported"))
		}

var namespace string
		if len(uniqueNamespaces) == 1 {
			namespace = uniqueNamespaces[0]
		} else {
			n, _, err := o.clientConfig.Namespace()
			if err != nil {
				return compError(err)
			}
			namespace = n
		}

kind, name := parts[0], parts[1]
		names, err := retrieveNamesFromResource(context.TODO(), o.client, namespace, kind)
		if err != nil {
			return compError(err)
		}
		for _, n := range names {
			if strings.HasPrefix(n, name) {
				comps = append(comps, kind+"/"+n)
			}
		}
		return comps, cobra.ShellCompDirectiveNoFileComp
	}
}

func compError(err error) ([]string, cobra.ShellCompDirective) {
	cobra.CompError(err.Error())
	return nil, cobra.ShellCompDirectiveError
}

func retrieveNamesFromResource(ctx context.Context, client kubernetes.Interface, namespace, kind string) ([]string, error) {
	opt := metav1.ListOptions{}
	var names []string
	switch {
	// core
	case stern.PodMatcher.Matches(kind):
		l, err := client.CoreV1().Pods(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	case stern.ReplicationControllerMatcher.Matches(kind):
		l, err := client.CoreV1().ReplicationControllers(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	case stern.ServiceMatcher.Matches(kind):
		l, err := client.CoreV1().Services(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	// apps
	case stern.DeploymentMatcher.Matches(kind):
		l, err := client.AppsV1().Deployments(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	case stern.DaemonSetMatcher.Matches(kind):
		l, err := client.AppsV1().DaemonSets(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	case stern.ReplicaSetMatcher.Matches(kind):
		l, err := client.AppsV1().ReplicaSets(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	case stern.StatefulSetMatcher.Matches(kind):
		l, err := client.AppsV1().StatefulSets(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	// batch
	case stern.JobMatcher.Matches(kind):
		l, err := client.BatchV1().Jobs(namespace).List(ctx, opt)
		if err != nil {
			return nil, err
		}
		for _, item := range l.Items {
			names = append(names, item.GetName())
		}
	default:
		return nil, fmt.Errorf("resource type %s is not supported", kind)
	}
	return names, nil
}
07070100000016000081A4000000000000000000000001659C910000000CF3000000000000000000000000000000000000002900000000stern-1.28.0/cmd/flag_completion_test.gopackage cmd

import (
	"context"
	"reflect"
	"testing"

appsv1 "k8s.io/api/apps/v1"
	batchv1 "k8s.io/api/batch/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/kubernetes/fake"
)

func TestRetrieveNamesFromResource(t *testing.T) {
	genMeta := func(name string) metav1.ObjectMeta {
		return metav1.ObjectMeta{
			Name:      name,
			Namespace: "ns1",
		}
	}
	objs := []runtime.Object{
		&corev1.Pod{ObjectMeta: genMeta("pod1")},
		&corev1.Pod{ObjectMeta: genMeta("pod2")},
		&corev1.Pod{ObjectMeta: genMeta("pod3")},
		&corev1.ReplicationController{ObjectMeta: genMeta("rc1")},
		&corev1.Service{ObjectMeta: genMeta("svc1")},
		&appsv1.Deployment{ObjectMeta: genMeta("deploy1")},
		&appsv1.Deployment{ObjectMeta: genMeta("deploy2")},
		&appsv1.DaemonSet{ObjectMeta: genMeta("ds1")},
		&appsv1.DaemonSet{ObjectMeta: genMeta("ds2")},
		&appsv1.ReplicaSet{ObjectMeta: genMeta("rs1")},
		&appsv1.ReplicaSet{ObjectMeta: genMeta("rs2")},
		&appsv1.StatefulSet{ObjectMeta: genMeta("sts1")},
		&appsv1.StatefulSet{ObjectMeta: genMeta("sts2")},
		&batchv1.Job{ObjectMeta: genMeta("job1")},
		&batchv1.Job{ObjectMeta: genMeta("job2")},
	}
	client := fake.NewSimpleClientset(objs...)
	tests := []struct {
		desc      string
		kinds     []string
		expected  []string
		wantError bool
	}{
		// core
		{
			desc:     "pods",
			kinds:    []string{"po", "pods", "pod"},
			expected: []string{"pod1", "pod2", "pod3"},
		},
		{
			desc:     "replicationcontrollers",
			kinds:    []string{"rc", "replicationcontrollers", "replicationcontroller"},
			expected: []string{"rc1"},
		},
		// apps
		{
			desc:     "deployments",
			kinds:    []string{"deploy", "deployments", "deployment"},
			expected: []string{"deploy1", "deploy2"},
		},
		{
			desc:     "daemonsets",
			kinds:    []string{"ds", "daemonsets", "daemonset"},
			expected: []string{"ds1", "ds2"},
		},
		{
			desc:     "replicasets",
			kinds:    []string{"rs", "replicasets", "replicaset"},
			expected: []string{"rs1", "rs2"},
		},
		{
			desc:     "statefulsets",
			kinds:    []string{"sts", "statefulsets", "statefulset"},
			expected: []string{"sts1", "sts2"},
		},
		// batch
		{
			desc:     "jobs",
			kinds:    []string{"job", "jobs"},
			expected: []string{"job1", "job2"},
		},
		// invalid
		{
			desc:      "invalid",
			kinds:     []string{"", "unknown"},
			wantError: true,
		},
	}

for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			for _, kind := range tt.kinds {
				names, err := retrieveNamesFromResource(context.Background(), client, "ns1", kind)
				if tt.wantError {
					if err == nil {
						t.Errorf("expected error, but got no error")
					}
					return
				}
				if err != nil {
					t.Errorf("unexpected error: %v", err)
					return
				}
				if !reflect.DeepEqual(tt.expected, names) {
					t.Errorf("expected %v, but actual %v", tt.expected, names)
				}
				// expect empty slice with no error when no objects are found in the valid resource
				names, err = retrieveNamesFromResource(context.Background(), client, "not-matched", kind)
				if err != nil {
					t.Errorf("unexpected error: %v", err)
					return
				}
				if len(names) != 0 {
					t.Errorf("expected empty slice, but got %v", names)
					return
				}
			}
		})
	}
}
07070100000017000081A4000000000000000000000001659C91000000065B000000000000000000000000000000000000002000000000stern-1.28.0/cmd/flag_prompt.gopackage cmd

import (
	"context"
	"fmt"
	"io"
	"sort"

"github.com/AlecAivazis/survey/v2"
	"github.com/fatih/color"
	"github.com/pkg/errors"
	"github.com/stern/stern/stern"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/client-go/kubernetes"
)

// promptHandler invokes the interactive prompt and updates config.LabelSelector with the selected value.
func promptHandler(ctx context.Context, client kubernetes.Interface, config *stern.Config, out io.Writer) error {
	labelsMap, err := stern.List(ctx, client, config)
	if err != nil {
		return err
	}

if len(labelsMap) == 0 {
		return errors.New("No matching labels")
	}

var choices []string

for key := range labelsMap {
		choices = append(choices, key)
	}

sort.Strings(choices)

choice, err := selectPods(choices)
	if err != nil {
		return err
	}

selector := fmt.Sprintf("%v=%v", labelsMap[choice], choice)

fmt.Fprintf(out, "Selector: %v\n", color.BlueString(selector))

labelSelector, err := labels.Parse(selector)
	if err != nil {
		return err
	}

config.LabelSelector = labelSelector

return nil
}

// selectPods surfaces an interactive prompt for selecting an app.kubernetes.io/instance.
func selectPods(pods []string) (string, error) {
	arrow := survey.WithIcons(func(icons *survey.IconSet) {
		icons.Question.Text = "❯"
		icons.SelectFocus.Text = "❯"
		icons.Question.Format = "blue"
		icons.SelectFocus.Format = "blue"
	})

prompt := &survey.Select{
		Message: "Select \"app.kubernetes.io/instance\" label value:",
		Options: pods,
	}

var pod string

if err := survey.AskOne(prompt, &pod, arrow); err != nil {
		return "", err
	}

return pod, nil
}
07070100000018000081A4000000000000000000000001659C910000000134000000000000000000000000000000000000002100000000stern-1.28.0/cmd/flag_version.gopackage cmd

import (
	"fmt"
	"io"
)

var (
	version = "dev"
	commit  = ""
	date    = ""
)

func outputVersionInfo(out io.Writer) {
	fmt.Fprintf(out, "version: %s\n", version)

if commit != "" {
		fmt.Fprintf(out, "commit: %s\n", commit)
	}

if date != "" {
		fmt.Fprintf(out, "built at: %s\n", date)
	}
}
07070100000019000081A4000000000000000000000001659C9100000000EE000000000000000000000000000000000000001A00000000stern-1.28.0/cmd/test.tpl{{color .PodColor .PodName}} {{color .ContainerColor .ContainerName}} {{ with $msg := .Message | tryParseJSON }}[{{ colorGreen (toRFC3339Nano (toUTC $msg.ts)) }}] {{ levelColor $msg.level }} {{ $msg.msg }}{{ else }}{{ .Message }}{{ end }}0707010000001A000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001A00000000stern-1.28.0/cmd/testdata0707010000001B000081A4000000000000000000000001659C910000000000000000000000000000000000000000000000002C00000000stern-1.28.0/cmd/testdata/config-empty.yaml0707010000001C000081A4000000000000000000000001659C91000000001C000000000000000000000000000000000000002E00000000stern-1.28.0/cmd/testdata/config-invalid.yamlthis is invalid config file
0707010000001D000081A4000000000000000000000001659C91000000000E000000000000000000000000000000000000003900000000stern-1.28.0/cmd/testdata/config-tail-invalid-value.yamltail: invalid
0707010000001E000081A4000000000000000000000001659C910000000008000000000000000000000000000000000000002C00000000stern-1.28.0/cmd/testdata/config-tail1.yamltail: 1
0707010000001F000081A4000000000000000000000001659C910000000015000000000000000000000000000000000000003500000000stern-1.28.0/cmd/testdata/config-unknown-option.yamlunknown: 999
tail: 1
07070100000020000081A4000000000000000000000001659C910000000D0E000000000000000000000000000000000000001400000000stern-1.28.0/go.modmodule github.com/stern/stern

go 1.21

require (
	github.com/AlecAivazis/survey/v2 v2.3.7
	github.com/fatih/color v1.16.0
	github.com/mitchellh/go-homedir v1.1.0
	github.com/pkg/errors v0.9.1
	github.com/spf13/cast v1.6.0
	github.com/spf13/cobra v1.8.0
	github.com/spf13/pflag v1.0.5
	golang.org/x/sync v0.6.0
	golang.org/x/time v0.5.0
	gopkg.in/yaml.v3 v3.0.1
	k8s.io/api v0.29.0
	k8s.io/apimachinery v0.29.0
	k8s.io/cli-runtime v0.29.0
	k8s.io/client-go v0.29.0
	k8s.io/klog/v2 v2.110.1
	k8s.io/utils v0.0.0-20240102154912-e7106e64919e
)

require (
	github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/emicklei/go-restful/v3 v3.11.1 // indirect
	github.com/evanphx/json-patch v5.7.0+incompatible // indirect
	github.com/go-errors/errors v1.5.1 // indirect
	github.com/go-logr/logr v1.4.1 // indirect
	github.com/go-openapi/jsonpointer v0.20.2 // indirect
	github.com/go-openapi/jsonreference v0.20.4 // indirect
	github.com/go-openapi/swag v0.22.7 // indirect
	github.com/gogo/protobuf v1.3.2 // indirect
	github.com/golang/protobuf v1.5.3 // indirect
	github.com/google/btree v1.1.2 // indirect
	github.com/google/gnostic-models v0.6.8 // indirect
	github.com/google/go-cmp v0.6.0 // indirect
	github.com/google/gofuzz v1.2.0 // indirect
	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
	github.com/google/uuid v1.5.0 // indirect
	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
	github.com/imdario/mergo v0.3.16 // indirect
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/josharian/intern v1.0.0 // indirect
	github.com/json-iterator/go v1.1.12 // indirect
	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
	github.com/mailru/easyjson v0.7.7 // indirect
	github.com/mattn/go-colorable v0.1.13 // indirect
	github.com/mattn/go-isatty v0.0.20 // indirect
	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
	github.com/moby/term v0.5.0 // indirect
	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
	github.com/modern-go/reflect2 v1.0.2 // indirect
	github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect
	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
	github.com/xlab/treeprint v1.2.0 // indirect
	go.starlark.net v0.0.0-20231121155337-90ade8b19d09 // indirect
	golang.org/x/net v0.20.0 // indirect
	golang.org/x/oauth2 v0.16.0 // indirect
	golang.org/x/sys v0.16.0 // indirect
	golang.org/x/term v0.16.0 // indirect
	golang.org/x/text v0.14.0 // indirect
	google.golang.org/appengine v1.6.8 // indirect
	google.golang.org/protobuf v1.32.0 // indirect
	gopkg.in/evanphx/json-patch.v5 v5.7.0 // indirect
	gopkg.in/inf.v0 v0.9.1 // indirect
	gopkg.in/yaml.v2 v2.4.0 // indirect
	k8s.io/kube-openapi v0.0.0-20240105020646-a37d4de58910 // indirect
	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
	sigs.k8s.io/kustomize/api v0.16.0 // indirect
	sigs.k8s.io/kustomize/kyaml v0.16.0 // indirect
	sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect
	sigs.k8s.io/yaml v1.4.0 // indirect
)
07070100000021000081A4000000000000000000000001659C910000005877000000000000000000000000000000000000001400000000stern-1.28.0/go.sumgithub.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkkhIiSjQ=
github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo=
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/emicklei/go-restful/v3 v3.11.1 h1:S+9bSbua1z3FgCnV0KKOSSZ3mDthb5NyEPL5gEpCvyk=
github.com/emicklei/go-restful/v3 v3.11.1/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
github.com/evanphx/json-patch v5.7.0+incompatible h1:vgGkfT/9f8zE6tvSCe74nfpAVDQ2tG6yudJd8LBksgI=
github.com/evanphx/json-patch v5.7.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
github.com/go-errors/errors v1.5.1 h1:ZwEMSLRCapFLflTpT7NKaAc7ukJ8ZPEjzlxt8rPN8bk=
github.com/go-errors/errors v1.5.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-openapi/jsonpointer v0.20.2 h1:mQc3nmndL8ZBzStEo3JYF8wzmeWffDH4VbXz58sAx6Q=
github.com/go-openapi/jsonpointer v0.20.2/go.mod h1:bHen+N0u1KEO3YlmqOjTT9Adn1RfD91Ar825/PuiRVs=
github.com/go-openapi/jsonreference v0.20.4 h1:bKlDxQxQJgwpUSgOENiMPzCTBVuc7vTdXSSgNeAhojU=
github.com/go-openapi/jsonreference v0.20.4/go.mod h1:5pZJyJP2MnYCpoeoMAql78cCHauHj0V9Lhc506VOpw4=
github.com/go-openapi/swag v0.22.7 h1:JWrc1uc/P9cSomxfnsFSVWoE1FW6bNbrVPmpQYpCcR8=
github.com/go-openapi/swag v0.22.7/go.mod h1:Gl91UqO+btAM0plGGxHqJcQZ1ZTy6jbmridBTsDy8A0=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU=
github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I=
github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJYCmNdQXq6neHJOYx3V6jnqNEec=
github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 h1:+ngKgrYPPJrOjhax5N+uePQ0Fh1Z7PheYoUI/0nzkPA=
github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4=
github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de h1:9TO3cAIGXtEhnIaL+V+BEER86oLrvS+kWobKpbJuye0=
github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de/go.mod h1:zAbeS9B/r2mtpb6U+EI2rYA5OAXxsYw6wTamcNW+zcE=
github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQE9x6ikvDFZS2mDVS3drnohI=
github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 h1:n6/2gBQ3RWajuToeY6ZtZTIKv2v7ThUy5KKusIT0yc0=
github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
github.com/onsi/ginkgo/v2 v2.13.0 h1:0jY9lJquiL8fcf3M4LAXN5aMlS/b2BV86HFFPCPMgE4=
github.com/onsi/ginkgo/v2 v2.13.0/go.mod h1:TE309ZR8s5FsKKpuB1YAQYBzCaAfUgatB/xlT/ETL/o=
github.com/onsi/gomega v1.29.0 h1:KIA/t2t5UBzoirT4H9tsML45GEbo3ouUnBHsCfD2tVg=
github.com/onsi/gomega v1.29.0/go.mod h1:9sxs+SwGrKI0+PWe4Fxa9tFQQBG5xSsSbMXOI8PPpoQ=
github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ=
github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
go.starlark.net v0.0.0-20231121155337-90ade8b19d09 h1:hzy3LFnSN8kuQK8h9tHl4ndF6UruMj47OqwqsS+/Ai4=
go.starlark.net v0.0.0-20231121155337-90ade8b19d09/go.mod h1:LcLNIzVOMp4oV+uusnpk+VU+SzXaJakUuBjoCSWH5dM=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ=
golang.org/x/oauth2 v0.16.0/go.mod h1:hqZ+0LWXsiVoZpeld6jVt06P3adbS2Uu911W1SsJv2o=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.12.0 h1:YW6HUoUmYBpwSgyaGaZq1fHjrBjX1rlpZ54T6mu2kss=
golang.org/x/tools v0.12.0/go.mod h1:Sc0INKfu04TlqNoRA1hgpFZbhYXHPr4V5DzpSBTPqQM=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/evanphx/json-patch.v5 v5.7.0 h1:dGKGylPlZ/jus2g1YqhhyzfH0gPy2R8/MYUpW/OslTY=
gopkg.in/evanphx/json-patch.v5 v5.7.0/go.mod h1:/kvTRh1TVm5wuM6OkHxqXtE/1nUZZpihg29RtuIyfvk=
gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
k8s.io/api v0.29.0 h1:NiCdQMY1QOp1H8lfRyeEf8eOwV6+0xA6XEE44ohDX2A=
k8s.io/api v0.29.0/go.mod h1:sdVmXoz2Bo/cb77Pxi71IPTSErEW32xa4aXwKH7gfBA=
k8s.io/apimachinery v0.29.0 h1:+ACVktwyicPz0oc6MTMLwa2Pw3ouLAfAon1wPLtG48o=
k8s.io/apimachinery v0.29.0/go.mod h1:eVBxQ/cwiJxH58eK/jd/vAk4mrxmVlnpBH5J2GbMeis=
k8s.io/cli-runtime v0.29.0 h1:q2kC3cex4rOBLfPOnMSzV2BIrrQlx97gxHJs21KxKS4=
k8s.io/cli-runtime v0.29.0/go.mod h1:VKudXp3X7wR45L+nER85YUzOQIru28HQpXr0mTdeCrk=
k8s.io/client-go v0.29.0 h1:KmlDtFcrdUzOYrBhXHgKw5ycWzc3ryPX5mQe0SkG3y8=
k8s.io/client-go v0.29.0/go.mod h1:yLkXH4HKMAywcrD82KMSmfYg2DlE8mepPR4JGSo5n38=
k8s.io/klog/v2 v2.110.1 h1:U/Af64HJf7FcwMcXyKm2RPM22WZzyR7OSpYj5tg3cL0=
k8s.io/klog/v2 v2.110.1/go.mod h1:YGtd1984u+GgbuZ7e08/yBuAfKLSO0+uR1Fhi6ExXjo=
k8s.io/kube-openapi v0.0.0-20240105020646-a37d4de58910 h1:1Rp/XEKP5uxPs6QrsngEHAxBjaAR78iJRiJq5Fi7LSU=
k8s.io/kube-openapi v0.0.0-20240105020646-a37d4de58910/go.mod h1:Pa1PvrP7ACSkuX6I7KYomY6cmMA0Tx86waBhDUgoKPw=
k8s.io/utils v0.0.0-20240102154912-e7106e64919e h1:eQ/4ljkx21sObifjzXwlPKpdGLrCfRziVtos3ofG/sQ=
k8s.io/utils v0.0.0-20240102154912-e7106e64919e/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd h1:EDPBXCAspyGV4jQlpZSudPeMmr1bNJefnuqLsRAsHZo=
sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd/go.mod h1:B8JuhiUyNFVKdsE8h686QcCxMaH6HrOAZj4vswFpcB0=
sigs.k8s.io/kustomize/api v0.16.0 h1:/zAR4FOQDCkgSDmVzV2uiFbuy9bhu3jEzthrHCuvm1g=
sigs.k8s.io/kustomize/api v0.16.0/go.mod h1:MnFZ7IP2YqVyVwMWoRxPtgl/5hpA+eCCrQR/866cm5c=
sigs.k8s.io/kustomize/kyaml v0.16.0 h1:6J33uKSoATlKZH16unr2XOhDI+otoe2sR3M8PDzW3K0=
sigs.k8s.io/kustomize/kyaml v0.16.0/go.mod h1:xOK/7i+vmE14N2FdFyugIshB8eF6ALpy7jI87Q2nRh4=
sigs.k8s.io/structured-merge-diff/v4 v4.4.1 h1:150L+0vs/8DA78h1u02ooW1/fFq/Lwr+sGiqlzvrtq4=
sigs.k8s.io/structured-merge-diff/v4 v4.4.1/go.mod h1:N8hJocpFajUSSeSJ9bOZ77VzejKZaXsTtZo4/u7Io08=
sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
07070100000022000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001200000000stern-1.28.0/hack07070100000023000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000002000000000stern-1.28.0/hack/update-readme07070100000024000081A4000000000000000000000001659C9100000010FA000000000000000000000000000000000000003100000000stern-1.28.0/hack/update-readme/update-readme.gopackage main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strings"

"github.com/spf13/pflag"
	"github.com/stern/stern/cmd"
	"k8s.io/cli-runtime/pkg/genericclioptions"
)

const (
	targetSectionBegin = ""
	targetSectionEnd   = ""
)

func main() {
	if len(os.Args) != 2 {
		fmt.Fprintln(os.Stderr, "readmePath argument required")
		os.Exit(1)
	}
	readmePath := os.Args[1]

flagsMarkdownTable := GenerateFlagsMarkdownTable()

readmeString, err := GenerateReadme(readmePath, flagsMarkdownTable)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

err = OverwriteReadme(readmePath, readmeString)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

// GenerateFlagsMarkdownTable generates markdown table of flag list.
// This function loads flag list and generates such as following text:
//
//	 flag            | default         | purpose
//	-----------------|-----------------|---------
//	 `--flag1`, `-f` |                 | This is flag1.
//	 `--flag2`       | `flag2-default` | This is flag2.
func GenerateFlagsMarkdownTable() string {
	fs := pflag.NewFlagSet("", pflag.ExitOnError)
	o := cmd.NewOptions(genericclioptions.NewTestIOStreamsDiscard())
	o.AddFlags(fs)

flagMaxlen, defaultMaxlen := len(" flag "), len(" default ")
	allTexts := make([][]string, 0)
	fs.VisitAll(func(flag *pflag.Flag) {
		// won't append deprecated flag
		if flag.Deprecated != "" {
			return
		}

if flag.Hidden {
			return
		}

flagText := ""
		if flag.Shorthand != "" {
			flagText = fmt.Sprintf(" `--%s`, `-%s` ", flag.Name, flag.Shorthand)
		} else {
			flagText = fmt.Sprintf(" `--%s` ", flag.Name)
		}
		if len(flagText) > flagMaxlen {
			flagMaxlen = len(flagText)
		}

flagTypeName, usage := pflag.UnquoteUsage(flag)
		defaultText := ""
		if flag.DefValue != "" {
			switch flagTypeName {
			// convert []string{"aaa", "bbb"} to "aaa,bbb"
			case "strings":
				stirngSlice, err := fs.GetStringSlice(flag.Name)
				if err != nil {
					panic(err)
				}

defaultValuesString := ""
				for _, s := range stirngSlice {
					defaultValuesString += fmt.Sprintf("%s,", s)
				}
				defaultValuesString = strings.TrimRight(defaultValuesString, ",")

if defaultValuesString != "" {
					defaultText += fmt.Sprintf(" `%s` ", defaultValuesString)
				}
			default:
				defaultText += fmt.Sprintf(" `%s` ", flag.DefValue)
			}
		}
		if len(defaultText) > defaultMaxlen {
			defaultMaxlen = len(defaultText)
		}

purposeText := fmt.Sprintf(" %s", usage)

allTexts = append(allTexts, []string{flagText, defaultText, purposeText})
	})

tableText := fmt.Sprintf(
		" flag %s| default %s| purpose\n",
		strings.Repeat(" ", flagMaxlen-len(" flag ")),
		strings.Repeat(" ", defaultMaxlen-len(" default ")))
	tableText += fmt.Sprintf(
		"%s|%s|%s\n",
		strings.Repeat("-", flagMaxlen),
		strings.Repeat("-", defaultMaxlen),
		strings.Repeat("-", len(" purpose ")))
	for _, text := range allTexts {
		tableText += text[0]
		tableText += strings.Repeat(" ", flagMaxlen-len(text[0]))
		tableText += "|" + text[1]
		tableText += strings.Repeat(" ", defaultMaxlen-len(text[1]))
		tableText += "|" + text[2]
		tableText += "\n"
	}

return tableText
}

// GenerateReadme generates README.md in which flags markdown table is embedded.
// Overwrite the section which specified as the target.
func GenerateReadme(readmePath, flagsMarkdownTable string) (string, error) {
	f, err := os.Open(readmePath)
	if err != nil {
		return "", err
	}
	defer f.Close()

buf, err := io.ReadAll(f)
	if err != nil {
		return "", err
	}

inTargetSection := false
	tableText := ""
	scanner := bufio.NewScanner(strings.NewReader(string(buf)))
	for scanner.Scan() {
		if !inTargetSection {
			tableText += scanner.Text() + "\n"
		}

if scanner.Text() == targetSectionBegin {
			inTargetSection = true
		}

if scanner.Text() == targetSectionEnd {
			tableText += flagsMarkdownTable
			tableText += scanner.Text() + "\n"
			inTargetSection = false
		}
	}

return tableText, nil
}

// OverwriteReadme overwrites README.md with passed readmeString.
func OverwriteReadme(readmePath, readmeString string) error {
	f, err := os.Create(readmePath)
	if err != nil {
		return err
	}
	defer f.Close()

_, err = f.WriteString(readmeString)
	if err != nil {
		return err
	}

return nil
}
07070100000025000081ED000000000000000000000001659C9100000001D3000000000000000000000000000000000000002300000000stern-1.28.0/hack/verify-readme.sh#!/usr/bin/env bash

set -eo pipefail; [[ -n "$DEBUG" ]] && set -ux

ROOT_DIR="$(cd "$(dirname $0)" && pwd)/.."
cd "$ROOT_DIR"

tempfile="$(mktemp)"
cat README.md >"$tempfile"
make update-readme README_FILE="$tempfile" >/dev/null
diff="$(diff -u ./README.md "$tempfile" ||:)"

if [[ -n "$diff" ]]; then
  echo "$diff" >&2
  echo "Error: Running update-readme made a difference in README.md." >&2
  echo "Maybe you forgot to run 'make update-readme'." >&2
  exit 1
fi
07070100000026000081A4000000000000000000000001659C9100000003BC000000000000000000000000000000000000001500000000stern-1.28.0/main.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package main

import (
	"log"
	"os"

"github.com/stern/stern/cmd"
	"k8s.io/cli-runtime/pkg/genericclioptions"
)

func main() {
	streams := genericclioptions.IOStreams{Out: os.Stdout, ErrOut: os.Stderr}
	stern, err := cmd.NewSternCmd(streams)
	if err != nil {
		log.Fatal(err)
	}

if err := stern.Execute(); err != nil {
		os.Exit(1)
	}
}
07070100000027000041ED000000000000000000000002659C910000000000000000000000000000000000000000000000001300000000stern-1.28.0/stern07070100000028000081A4000000000000000000000001659C910000000691000000000000000000000000000000000000001D00000000stern-1.28.0/stern/config.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"io"
	"regexp"
	"text/template"
	"time"

"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
)

// Config contains the config for stern
type Config struct {
	Namespaces            []string
	PodQuery              *regexp.Regexp
	ExcludePodQuery       []*regexp.Regexp
	Timestamps            bool
	TimestampFormat       string
	Location              *time.Location
	ContainerQuery        *regexp.Regexp
	ExcludeContainerQuery []*regexp.Regexp
	ContainerStates       []ContainerState
	Exclude               []*regexp.Regexp
	Include               []*regexp.Regexp
	Highlight             []*regexp.Regexp
	InitContainers        bool
	EphemeralContainers   bool
	Since                 time.Duration
	AllNamespaces         bool
	LabelSelector         labels.Selector
	FieldSelector         fields.Selector
	TailLines             *int64
	Template              *template.Template
	Follow                bool
	Resource              string
	OnlyLogLines          bool
	MaxLogRequests        int

Out    io.Writer
	ErrOut io.Writer
}
07070100000029000081A4000000000000000000000001659C91000000067C000000000000000000000000000000000000002600000000stern-1.28.0/stern/container_state.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"errors"

v1 "k8s.io/api/core/v1"
)

type ContainerState string

const (
	RUNNING    = "running"
	WAITING    = "waiting"
	TERMINATED = "terminated"
	ALL_STATES = "all"
)

// NewContainerState returns corresponding ContainerState
func NewContainerState(stateConfig string) (ContainerState, error) {
	if stateConfig == RUNNING {
		return RUNNING, nil
	} else if stateConfig == WAITING {
		return WAITING, nil
	} else if stateConfig == TERMINATED {
		return TERMINATED, nil
	} else if stateConfig == ALL_STATES {
		return ALL_STATES, nil
	}

return "", errors.New("containerState should be one of 'running', 'waiting', 'terminated', or 'all'")
}

// Match returns ContainerState is matched
func (stateConfig ContainerState) Match(containerState v1.ContainerState) bool {
	if stateConfig == ALL_STATES {
		return true
	}
	return (stateConfig == RUNNING && containerState.Running != nil) ||
		(stateConfig == WAITING && containerState.Waiting != nil) ||
		(stateConfig == TERMINATED && containerState.Terminated != nil)
}
0707010000002A000081A4000000000000000000000001659C9100000007DC000000000000000000000000000000000000002B00000000stern-1.28.0/stern/container_state_test.gopackage stern

import (
	"testing"

v1 "k8s.io/api/core/v1"
)

func TestNewContainerState(t *testing.T) {
	tests := []struct {
		stateConfig string
		expected    ContainerState
		isError     bool
	}{
		{
			"running",
			ContainerState(RUNNING),
			false,
		},
		{
			"waiting",
			ContainerState(WAITING),
			false,
		},
		{
			"terminated",
			ContainerState(TERMINATED),
			false,
		},
		{
			"all",
			ContainerState(ALL_STATES),
			false,
		},
		{
			"wrongValue",
			ContainerState(""),
			true,
		},
	}

for i, tt := range tests {
		containerState, err := NewContainerState(tt.stateConfig)

if tt.expected != containerState {
			t.Errorf("%d: expected %v, but actual %v", i, tt.expected, containerState)
		}

if (tt.isError && err == nil) || (!tt.isError && err != nil) {
			t.Errorf("%d: expected error is %v, but actual %v", i, tt.isError, err)
		}
	}
}

func TestMatch(t *testing.T) {
	tests := []struct {
		containerState   ContainerState
		v1ContainerState v1.ContainerState
		expected         bool
	}{
		{
			ContainerState(RUNNING),
			v1.ContainerState{
				Running:    &v1.ContainerStateRunning{},
				Waiting:    nil,
				Terminated: nil,
			},
			true,
		},
		{
			ContainerState(WAITING),
			v1.ContainerState{
				Running:    nil,
				Waiting:    &v1.ContainerStateWaiting{},
				Terminated: nil,
			},
			true,
		},
		{
			ContainerState(TERMINATED),
			v1.ContainerState{
				Running:    nil,
				Waiting:    nil,
				Terminated: &v1.ContainerStateTerminated{},
			},
			true,
		},
		{
			// "all" always matches all containers regardless of their states
			ContainerState(ALL_STATES),
			v1.ContainerState{},
			true,
		},
		{
			ContainerState(RUNNING),
			v1.ContainerState{
				Running:    nil,
				Waiting:    &v1.ContainerStateWaiting{},
				Terminated: nil,
			},
			false,
		},
	}

for i, tt := range tests {
		actual := tt.containerState.Match(tt.v1ContainerState)

if tt.expected != actual {
			t.Errorf("%d: expected %v, but actual %v", i, tt.expected, actual)
		}
	}
}
0707010000002B000081A4000000000000000000000001659C91000000097A000000000000000000000000000000000000001B00000000stern-1.28.0/stern/list.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"context"
	"sync"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/client-go/kubernetes"
	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
)

// List returns a map of all 'app.kubernetes.io/instance' values.
func List(ctx context.Context, client kubernetes.Interface, config *Config) (map[string]string, error) {
	var namespaces []string
	// A specific namespace is ignored if all-namespaces is provided.
	if config.AllNamespaces {
		namespaces = []string{""}
	} else {
		namespaces = config.Namespaces
	}

labels := make(map[string]string)
	options := metav1.ListOptions{}

wg := sync.WaitGroup{}

wg.Add(len(namespaces))

// Concurrently iterate through provided namespaces.
	for _, n := range namespaces {
		go func(n string) {
			defer wg.Done()

pods, err := client.CoreV1().Pods(n).List(ctx, options)
			if err != nil {
				return
			}

match := "app.kubernetes.io/instance"
			// Iterate through pods in namespace, looking for matching labels.
			for _, pod := range pods.Items {
				key := pod.Labels[match]

if key == "" {
					continue
				}

labels[key] = match
			}
		}(n)
	}

wg.Wait()

return labels, nil
}

// ListTargets returns targets by listing and filtering pods
func ListTargets(ctx context.Context, i corev1client.PodInterface, labelSelector labels.Selector, fieldSelector fields.Selector, filter *targetFilter) ([]*Target, error) {
	list, err := i.List(ctx, metav1.ListOptions{LabelSelector: labelSelector.String(), FieldSelector: fieldSelector.String()})
	if err != nil {
		return nil, err
	}
	var targets []*Target
	for i := range list.Items {
		filter.visit(&list.Items[i], func(t *Target) {
			targets = append(targets, t)
		})
	}
	return targets, nil
}
0707010000002C000081A4000000000000000000000001659C910000000986000000000000000000000000000000000000002700000000stern-1.28.0/stern/resource_matcher.go//   Copyright 2017 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

// ResourceMatcher is a matcher for Kubernetes resources
type ResourceMatcher struct {
	name    string   // the resource name in singular e.g. "deployment"
	aliases []string // the aliases of the resource e.g. "deploy" and "deployments"
}

// Name returns the resource name in singular
func (r *ResourceMatcher) Name() string {
	return r.name
}

// AllNames returns the resource names including the aliases
func (r *ResourceMatcher) AllNames() []string {
	return append(r.aliases, r.name)
}

// Matches returns if name matches one of the resource names
func (r *ResourceMatcher) Matches(name string) bool {
	for _, n := range r.AllNames() {
		if n == name {
			return true
		}
	}
	return false
}

var (
	PodMatcher                   = ResourceMatcher{name: "pod", aliases: []string{"po", "pods"}}
	ReplicationControllerMatcher = ResourceMatcher{name: "replicationcontroller", aliases: []string{"rc", "replicationcontrollers"}}
	ServiceMatcher               = ResourceMatcher{name: "service", aliases: []string{"svc", "services"}}
	DaemonSetMatcher             = ResourceMatcher{name: "daemonset", aliases: []string{"ds", "daemonsets"}}
	DeploymentMatcher            = ResourceMatcher{name: "deployment", aliases: []string{"deploy", "deployments"}}
	ReplicaSetMatcher            = ResourceMatcher{name: "replicaset", aliases: []string{"rs", "replicasets"}}
	StatefulSetMatcher           = ResourceMatcher{name: "statefulset", aliases: []string{"sts", "statefulsets"}}
	JobMatcher                   = ResourceMatcher{name: "job", aliases: []string{"jobs"}} // job does not have a short name
	ResourceMatchers             = []ResourceMatcher{
		PodMatcher,
		ReplicationControllerMatcher,
		ServiceMatcher,
		DeploymentMatcher,
		DaemonSetMatcher,
		ReplicaSetMatcher,
		StatefulSetMatcher,
		JobMatcher,
	}
)
0707010000002D000081A4000000000000000000000001659C910000001F22000000000000000000000000000000000000001C00000000stern-1.28.0/stern/stern.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"context"
	"fmt"
	"regexp"
	"strings"
	"time"

"sync/atomic"

"github.com/pkg/errors"

"golang.org/x/sync/errgroup"
	"golang.org/x/time/rate"

"k8s.io/apimachinery/pkg/labels"
	"k8s.io/utils/ptr"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
)

// Run starts the main run loop
func Run(ctx context.Context, client kubernetes.Interface, config *Config) error {
	var namespaces []string
	// A specific namespace is ignored if all-namespaces is provided
	if config.AllNamespaces {
		namespaces = []string{""}
	} else {
		namespaces = config.Namespaces
		if len(namespaces) == 0 {
			return errors.New("no namespace specified")
		}
	}

var resource struct {
		kind string
		name string
	}
	if config.Resource != "" {
		parts := strings.Split(config.Resource, "/")
		if len(parts) != 2 {
			return errors.New("resource must be specified in the form \"<resource>/<name>\"")
		}
		resource.kind, resource.name = parts[0], parts[1]
		if PodMatcher.Matches(resource.kind) {
			// Pods might have no labels or share the same labels,
			// so we use an exact match instead.
			podName, err := regexp.Compile("^" + resource.name + "$")
			if err != nil {
				return errors.Wrap(err, "failed to compile regular expression for pod")
			}
			config.PodQuery = podName
		}
	}

filter := newTargetFilter(targetFilterConfig{
		podFilter:              config.PodQuery,
		excludePodFilter:       config.ExcludePodQuery,
		containerFilter:        config.ContainerQuery,
		containerExcludeFilter: config.ExcludeContainerQuery,
		initContainers:         config.InitContainers,
		ephemeralContainers:    config.EphemeralContainers,
		containerStates:        config.ContainerStates,
	})
	newTail := func(t *Target) *Tail {
		return NewTail(client.CoreV1(), t.Node, t.Namespace, t.Pod, t.Container, config.Template, config.Out, config.ErrOut, &TailOptions{
			Timestamps:      config.Timestamps,
			TimestampFormat: config.TimestampFormat,
			Location:        config.Location,
			SinceSeconds:    ptr.To[int64](int64(config.Since.Seconds())),
			Exclude:         config.Exclude,
			Include:         config.Include,
			Highlight:       config.Highlight,
			Namespace:       config.AllNamespaces || len(namespaces) > 1,
			TailLines:       config.TailLines,
			Follow:          config.Follow,
			OnlyLogLines:    config.OnlyLogLines,
		})
	}

if !config.Follow {
		var eg errgroup.Group
		eg.SetLimit(config.MaxLogRequests)
		for _, n := range namespaces {
			selector, err := chooseSelector(ctx, client, n, resource.kind, resource.name, config.LabelSelector)
			if err != nil {
				return err
			}
			targets, err := ListTargets(ctx,
				client.CoreV1().Pods(n),
				selector,
				config.FieldSelector,
				filter,
			)
			if err != nil {
				return err
			}
			for _, t := range targets {
				t := t
				eg.Go(func() error {
					tail := newTail(t)
					defer tail.Close()
					return tail.Start(ctx)
				})
			}
		}
		return eg.Wait()
	}

tailTarget := func(ctx context.Context, target *Target) {
		// We use a rate limiter to prevent a burst of retries.
		// It also enables us to retry immediately, in most cases,
		// when it is disconnected on the way.
		limiter := rate.NewLimiter(rate.Every(time.Second*20), 2)
		var resumeRequest *ResumeRequest
		for {
			if err := limiter.Wait(ctx); err != nil {
				fmt.Fprintf(config.ErrOut, "failed to retry: %v\n", err)
				return
			}
			tail := newTail(target)
			var err error
			if resumeRequest == nil {
				err = tail.Start(ctx)
			} else {
				err = tail.Resume(ctx, resumeRequest)
			}
			tail.Close()
			if err == nil {
				return
			}
			if !filter.isActive(target) {
				fmt.Fprintf(config.ErrOut, "failed to tail: %v\n", err)
				return
			}
			fmt.Fprintf(config.ErrOut, "failed to tail: %v, will retry\n", err)
			if resumeReq := tail.GetResumeRequest(); resumeReq != nil {
				resumeRequest = resumeReq
			}
		}
	}

eg, nctx := errgroup.WithContext(ctx)
	var numRequests atomic.Int64
	for _, n := range namespaces {
		selector, err := chooseSelector(nctx, client, n, resource.kind, resource.name, config.LabelSelector)
		if err != nil {
			return err
		}
		a, err := WatchTargets(nctx,
			client.CoreV1().Pods(n),
			selector,
			config.FieldSelector,
			filter,
		)
		if err != nil {
			return errors.Wrap(err, "failed to set up watch")
		}

eg.Go(func() error {
			for {
				select {
				case target, ok := <-a:
					if !ok {
						return fmt.Errorf("lost watch connection")
					}
					numRequests.Add(1)
					if numRequests.Load() > int64(config.MaxLogRequests) {
						return fmt.Errorf(
							"stern reached the maximum number of log requests (%d),"+
								" use --max-log-requests to increase the limit",
							config.MaxLogRequests)
					}
					go func() {
						tailTarget(nctx, target)
						numRequests.Add(-1)
					}()
				case <-nctx.Done():
					return nil
				}
			}
		})
	}
	return eg.Wait()
}

func chooseSelector(ctx context.Context, client kubernetes.Interface, namespace, kind, name string, selector labels.Selector) (labels.Selector, error) {
	if kind == "" {
		return selector, nil
	}
	if PodMatcher.Matches(kind) {
		// We use an exact match for pods instead of a label to select pods without labels.
		return labels.Everything(), nil
	}
	labelMap, err := retrieveLabelsFromResource(ctx, client, namespace, kind, name)
	if err != nil {
		return nil, err
	}
	if len(labelMap) == 0 {
		return nil, fmt.Errorf("resource %s/%s has no labels to select", kind, name)
	}
	return labels.SelectorFromSet(labelMap), nil
}

func retrieveLabelsFromResource(ctx context.Context, client kubernetes.Interface, namespace, kind, name string) (map[string]string, error) {
	opt := metav1.GetOptions{}
	switch {
	// core
	case ReplicationControllerMatcher.Matches(kind):
		o, err := client.CoreV1().ReplicationControllers(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		if o.Spec.Template == nil { // RC's spec.template is a pointer field
			return nil, fmt.Errorf("%s does not have spec.template", name)
		}
		return o.Spec.Template.Labels, nil
	case ServiceMatcher.Matches(kind):
		o, err := client.CoreV1().Services(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Selector, nil
	// apps
	case DaemonSetMatcher.Matches(kind):
		o, err := client.AppsV1().DaemonSets(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Template.Labels, nil
	case DeploymentMatcher.Matches(kind):
		o, err := client.AppsV1().Deployments(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Template.Labels, nil
	case ReplicaSetMatcher.Matches(kind):
		o, err := client.AppsV1().ReplicaSets(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Template.Labels, nil
	case StatefulSetMatcher.Matches(kind):
		o, err := client.AppsV1().StatefulSets(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Template.Labels, nil
	// batch
	// We do not support cronjobs because they might not have labels to select.
	case JobMatcher.Matches(kind):
		o, err := client.BatchV1().Jobs(namespace).Get(ctx, name, opt)
		if err != nil {
			return nil, err
		}
		return o.Spec.Template.Labels, nil
	}
	return nil, fmt.Errorf("resource type %s is not supported", kind)
}
0707010000002E000081A4000000000000000000000001659C91000000104F000000000000000000000000000000000000002100000000stern-1.28.0/stern/stern_test.gopackage stern

import (
	"context"
	"reflect"
	"testing"

appsv1 "k8s.io/api/apps/v1"
	batchv1 "k8s.io/api/batch/v1"
	corev1 "k8s.io/api/core/v1"

kerrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/client-go/kubernetes/fake"
)

func TestRetrieveLabelsFromResource(t *testing.T) {
	genMeta := func(name string) metav1.ObjectMeta {
		return metav1.ObjectMeta{
			Name:      name,
			Namespace: "ns1",
		}
	}
	genPodTemplateSpec := func(name string) corev1.PodTemplateSpec {
		return corev1.PodTemplateSpec{
			ObjectMeta: metav1.ObjectMeta{
				Labels: map[string]string{
					"app": name,
				},
			},
		}
	}
	objs := []runtime.Object{
		// core
		&corev1.ReplicationController{
			ObjectMeta: genMeta("rc1"),
			Spec: corev1.ReplicationControllerSpec{
				Template: &corev1.PodTemplateSpec{
					ObjectMeta: metav1.ObjectMeta{
						Labels: map[string]string{
							"app": "rc-label",
						},
					},
				},
			},
		},
		&corev1.Service{
			ObjectMeta: genMeta("svc1"),
			Spec: corev1.ServiceSpec{
				Selector: map[string]string{
					"app": "svc-label",
				},
			},
		},
		// apps
		&appsv1.DaemonSet{
			ObjectMeta: genMeta("ds1"),
			Spec: appsv1.DaemonSetSpec{
				Template: genPodTemplateSpec("ds-label"),
			},
		},
		&appsv1.Deployment{
			ObjectMeta: genMeta("deploy1"),
			Spec: appsv1.DeploymentSpec{
				Template: genPodTemplateSpec("deploy-label"),
			},
		},
		&appsv1.ReplicaSet{
			ObjectMeta: genMeta("rs1"),
			Spec: appsv1.ReplicaSetSpec{
				Template: genPodTemplateSpec("rs-label"),
			},
		},
		&appsv1.StatefulSet{
			ObjectMeta: genMeta("sts1"),
			Spec: appsv1.StatefulSetSpec{
				Template: genPodTemplateSpec("sts-label"),
			},
		},
		// batch
		&batchv1.Job{
			ObjectMeta: genMeta("job1"),
			Spec: batchv1.JobSpec{
				Template: genPodTemplateSpec("job-label"),
			},
		},
		&batchv1.CronJob{
			ObjectMeta: genMeta("cj1"),
			Spec: batchv1.CronJobSpec{
				JobTemplate: batchv1.JobTemplateSpec{
					Spec: batchv1.JobSpec{
						Template: genPodTemplateSpec("cj-label"),
					},
				},
			},
		},
	}
	client := fake.NewSimpleClientset(objs...)
	tests := []struct {
		desc      string
		kinds     []string
		name      string
		label     string
		wantError bool
	}{
		// core
		{
			desc:  "replicationcontrollers",
			kinds: []string{"rc", "replicationcontrollers", "replicationcontroller"},
			name:  "rc1",
			label: "rc-label",
		},
		{
			desc:  "services",
			kinds: []string{"svc", "services", "service"},
			name:  "svc1",
			label: "svc-label",
		},
		// apps
		{
			desc:  "daemonsets",
			kinds: []string{"ds", "daemonsets", "daemonset"},
			name:  "ds1",
			label: "ds-label",
		},
		{
			desc:  "deployments",
			kinds: []string{"deploy", "deployments", "deployment"},
			name:  "deploy1",
			label: "deploy-label",
		},
		{
			desc:  "replicasets",
			kinds: []string{"rs", "replicasets", "replicaset"},
			name:  "rs1",
			label: "rs-label",
		},
		{
			desc:  "statefulsets",
			kinds: []string{"sts", "statefulsets", "statefulset"},
			name:  "sts1",
			label: "sts-label",
		},
		// batch
		{
			desc:  "jobs",
			kinds: []string{"job", "jobs"},
			name:  "job1",
			label: "job-label",
		},
		// invalid
		{
			desc:      "invalid",
			kinds:     []string{"", "unknown"},
			name:      "dummy",
			wantError: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			for _, kind := range tt.kinds {
				labels, err := retrieveLabelsFromResource(context.Background(), client, "ns1", kind, tt.name)
				if tt.wantError {
					if err == nil {
						t.Errorf("expected error, but got no error")
					}
					return
				}
				if err != nil {
					t.Errorf("unexpected error: %v", err)
					return
				}
				expectedLabels := map[string]string{"app": tt.label}
				if !reflect.DeepEqual(expectedLabels, labels) {
					t.Errorf("expected %v, but actual %v", expectedLabels, labels)
				}

// test not found
				_, err = retrieveLabelsFromResource(context.Background(), client, "ns1", kind, "not-found")
				if !kerrors.IsNotFound(err) {
					t.Errorf("expected not found, but actual %v", err)
				}
			}
		})
	}
}
0707010000002F000081A4000000000000000000000001659C910000002993000000000000000000000000000000000000001B00000000stern-1.28.0/stern/tail.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"hash/fnv"
	"io"
	"regexp"
	"sort"
	"strings"
	"text/template"
	"time"
	"unicode"

"github.com/fatih/color"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
	"k8s.io/client-go/rest"
)

// RFC3339Nano with trailing zeros
const TimestampFormatDefault = "2006-01-02T15:04:05.000000000Z07:00"

// time.DateTime without year
const TimestampFormatShort = "01-02 15:04:05"

type Tail struct {
	clientset corev1client.CoreV1Interface

NodeName       string
	Namespace      string
	PodName        string
	ContainerName  string
	Options        *TailOptions
	closed         chan struct{}
	podColor       *color.Color
	containerColor *color.Color
	tmpl           *template.Template
	last           struct {
		timestamp string // RFC3339 timestamp (not RFC3339Nano)
		lines     int    // the number of lines seen during this timestamp
	}
	resumeRequest *ResumeRequest
	out           io.Writer
	errOut        io.Writer
}

type TailOptions struct {
	Timestamps      bool
	TimestampFormat string
	Location        *time.Location

SinceSeconds *int64
	SinceTime    *metav1.Time
	Exclude      []*regexp.Regexp
	Include      []*regexp.Regexp
	Highlight    []*regexp.Regexp
	Namespace    bool
	TailLines    *int64
	Follow       bool
	OnlyLogLines bool

// regexp for highlighting the matched string
	reHightlight *regexp.Regexp
}

type ResumeRequest struct {
	Timestamp   string // RFC3339 timestamp (not RFC3339Nano)
	LinesToSkip int    // the number of lines to skip during this timestamp
}

func (o TailOptions) IsExclude(msg string) bool {
	for _, rex := range o.Exclude {
		if rex.MatchString(msg) {
			return true
		}
	}

return false
}

func (o TailOptions) IsInclude(msg string) bool {
	if len(o.Include) == 0 {
		return true
	}

for _, rin := range o.Include {
		if rin.MatchString(msg) {
			return true
		}
	}

return false
}

var colorHighlight = color.New(color.FgRed, color.Bold).SprintFunc()

func (o TailOptions) HighlightMatchedString(msg string) string {
	highlight := append(o.Include, o.Highlight...)
	if len(highlight) == 0 {
		return msg
	}

if o.reHightlight == nil {
		ss := make([]string, len(highlight))
		for i, hl := range highlight {
			ss[i] = hl.String()
		}

// We expect a longer match
		sort.Slice(ss, func(i, j int) bool {
			return len(ss[i]) > len(ss[j])
		})

o.reHightlight = regexp.MustCompile("(" + strings.Join(ss, "|") + ")")
	}

msg = o.reHightlight.ReplaceAllStringFunc(msg, func(part string) string {
		return colorHighlight(part)
	})

return msg
}

func (o TailOptions) UpdateTimezoneAndFormat(timestamp string) (string, error) {
	t, err := time.ParseInLocation(time.RFC3339Nano, timestamp, time.UTC)
	if err != nil {
		return "", errors.New("missing timestamp")
	}
	format := TimestampFormatDefault
	if o.TimestampFormat != "" {
		format = o.TimestampFormat
	}
	return t.In(o.Location).Format(format), nil
}

// NewTail returns a new tail for a Kubernetes container inside a pod
func NewTail(clientset corev1client.CoreV1Interface, nodeName, namespace, podName, containerName string, tmpl *template.Template, out, errOut io.Writer, options *TailOptions) *Tail {
	podColor, containerColor := determineColor(podName)

return &Tail{
		clientset:      clientset,
		NodeName:       nodeName,
		Namespace:      namespace,
		PodName:        podName,
		ContainerName:  containerName,
		Options:        options,
		closed:         make(chan struct{}),
		tmpl:           tmpl,
		podColor:       podColor,
		containerColor: containerColor,

out:    out,
		errOut: errOut,
	}
}

var colorList = [][2]*color.Color{
	{color.New(color.FgHiCyan), color.New(color.FgCyan)},
	{color.New(color.FgHiGreen), color.New(color.FgGreen)},
	{color.New(color.FgHiMagenta), color.New(color.FgMagenta)},
	{color.New(color.FgHiYellow), color.New(color.FgYellow)},
	{color.New(color.FgHiBlue), color.New(color.FgBlue)},
	{color.New(color.FgHiRed), color.New(color.FgRed)},
}

func determineColor(podName string) (podColor, containerColor *color.Color) {
	hash := fnv.New32()
	_, _ = hash.Write([]byte(podName))
	idx := hash.Sum32() % uint32(len(colorList))

colors := colorList[idx]
	return colors[0], colors[1]
}

// Start starts tailing
func (t *Tail) Start(ctx context.Context) error {
	ctx, cancel := context.WithCancel(ctx)
	go func() {
		<-t.closed
		cancel()
	}()

t.printStarting()

req := t.clientset.Pods(t.Namespace).GetLogs(t.PodName, &corev1.PodLogOptions{
		Follow:       t.Options.Follow,
		Timestamps:   true,
		Container:    t.ContainerName,
		SinceSeconds: t.Options.SinceSeconds,
		SinceTime:    t.Options.SinceTime,
		TailLines:    t.Options.TailLines,
	})

err := t.ConsumeRequest(ctx, req)

if errors.Is(err, context.Canceled) {
		return nil
	}

return err
}

func (t *Tail) Resume(ctx context.Context, resumeRequest *ResumeRequest) error {
	sinceTime, err := resumeRequest.sinceTime()
	if err != nil {
		fmt.Fprintf(t.errOut, "failed to resume: %s, fallback to Start()\n", err)
		return t.Start(ctx)
	}
	t.resumeRequest = resumeRequest
	t.Options.SinceTime = sinceTime
	t.Options.SinceSeconds = nil
	t.Options.TailLines = nil
	return t.Start(ctx)
}

// Close stops tailing
func (t *Tail) Close() {
	t.printStopping()

close(t.closed)
}

func (t *Tail) printStarting() {
	if !t.Options.OnlyLogLines {
		g := color.New(color.FgHiGreen, color.Bold).SprintFunc()
		p := t.podColor.SprintFunc()
		c := t.containerColor.SprintFunc()
		if t.Options.Namespace {
			fmt.Fprintf(t.errOut, "%s %s %s › %s\n", g("+"), p(t.Namespace), p(t.PodName), c(t.ContainerName))
		} else {
			fmt.Fprintf(t.errOut, "%s %s › %s\n", g("+"), p(t.PodName), c(t.ContainerName))
		}
	}
}

func (t *Tail) printStopping() {
	if !t.Options.OnlyLogLines {
		r := color.New(color.FgHiRed, color.Bold).SprintFunc()
		p := t.podColor.SprintFunc()
		c := t.containerColor.SprintFunc()
		if t.Options.Namespace {
			fmt.Fprintf(t.errOut, "%s %s %s › %s\n", r("-"), p(t.Namespace), p(t.PodName), c(t.ContainerName))
		} else {
			fmt.Fprintf(t.errOut, "%s %s › %s\n", r("-"), p(t.PodName), c(t.ContainerName))
		}
	}
}

// ConsumeRequest reads the data from request and writes into the out
// writer.
func (t *Tail) ConsumeRequest(ctx context.Context, request rest.ResponseWrapper) error {
	stream, err := request.Stream(ctx)
	if err != nil {
		return err
	}
	defer stream.Close()

r := bufio.NewReader(stream)
	for {
		line, err := r.ReadBytes('\n')
		if len(line) != 0 {
			t.consumeLine(strings.TrimSuffix(string(line), "\n"))
		}

if err != nil {
			if err != io.EOF {
				return err
			}
			return nil
		}
	}
}

// Print prints a color coded log message with the pod and container names
func (t *Tail) Print(msg string) {
	vm := Log{
		Message:        msg,
		NodeName:       t.NodeName,
		Namespace:      t.Namespace,
		PodName:        t.PodName,
		ContainerName:  t.ContainerName,
		PodColor:       t.podColor,
		ContainerColor: t.containerColor,
	}

var buf bytes.Buffer
	if err := t.tmpl.Execute(&buf, vm); err != nil {
		fmt.Fprintf(t.errOut, "expanding template failed: %s\n", err)
		return
	}

fmt.Fprint(t.out, buf.String())
}

func (t *Tail) GetResumeRequest() *ResumeRequest {
	if t.last.timestamp == "" {
		return nil
	}
	return &ResumeRequest{Timestamp: t.last.timestamp, LinesToSkip: t.last.lines}
}

func (t *Tail) consumeLine(line string) {
	rfc3339Nano, content, err := splitLogLine(line)
	if err != nil {
		t.Print(fmt.Sprintf("[%v] %s", err, line))
		return
	}

// PodLogOptions.SinceTime is RFC3339, not RFC3339Nano.
	// We convert it to RFC3339 to skip the lines seen during this timestamp when resuming.
	rfc3339 := removeSubsecond(rfc3339Nano)
	t.rememberLastTimestamp(rfc3339)
	if t.resumeRequest.shouldSkip(rfc3339) {
		return
	}

if t.Options.IsExclude(content) || !t.Options.IsInclude(content) {
		return
	}

msg := t.Options.HighlightMatchedString(content)

if t.Options.Timestamps {
		updatedTs, err := t.Options.UpdateTimezoneAndFormat(rfc3339Nano)
		if err != nil {
			t.Print(fmt.Sprintf("[%v] %s", err, line))
			return
		}
		msg = updatedTs + " " + msg
	}

t.Print(msg)
}

func (t *Tail) rememberLastTimestamp(timestamp string) {
	if t.last.timestamp == timestamp {
		t.last.lines++
		return
	}
	t.last.timestamp = timestamp
	t.last.lines = 1
}

// Log is the object which will be used together with the template to generate
// the output.
type Log struct {
	// Message is the log message itself
	Message string `json:"message"`

// Node name of the pod
	NodeName string `json:"nodeName"`

// Namespace of the pod
	Namespace string `json:"namespace"`

// PodName of the pod
	PodName string `json:"podName"`

// ContainerName of the container
	ContainerName string `json:"containerName"`

PodColor       *color.Color `json:"-"`
	ContainerColor *color.Color `json:"-"`
}

func (r *ResumeRequest) sinceTime() (*metav1.Time, error) {
	sinceTime, err := time.Parse(time.RFC3339, r.Timestamp)

if err != nil {
		return nil, err
	}
	metaTime := metav1.NewTime(sinceTime)
	return &metaTime, nil
}

func (r *ResumeRequest) shouldSkip(timestamp string) bool {
	if r == nil {
		return false
	}
	if r.Timestamp == "" {
		return false
	}
	if r.Timestamp != timestamp {
		return false
	}
	if r.LinesToSkip <= 0 {
		return false
	}
	r.LinesToSkip--
	return true
}

func splitLogLine(line string) (timestamp string, content string, err error) {
	idx := strings.IndexRune(line, ' ')
	if idx == -1 {
		return "", "", errors.New("missing timestamp")
	}
	return line[:idx], line[idx+1:], nil
}

// removeSubsecond removes the subsecond of the timestamp.
// It converts RFC3339Nano to RFC3339 fast.
func removeSubsecond(timestamp string) string {
	dot := strings.IndexRune(timestamp, '.')
	if dot == -1 {
		return timestamp
	}
	var last int
	for i := dot; i < len(timestamp); i++ {
		if unicode.IsDigit(rune(timestamp[i])) {
			last = i
		}
	}
	if last == 0 {
		return timestamp
	}
	return timestamp[:dot] + timestamp[last+1:]
}
07070100000030000081A4000000000000000000000001659C910000003430000000000000000000000000000000000000002000000000stern-1.28.0/stern/tail_test.gopackage stern

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"reflect"
	"regexp"
	"testing"
	"text/template"
	"time"

"github.com/fatih/color"
	"k8s.io/client-go/kubernetes/fake"
)

func TestDetermineColor(t *testing.T) {
	podName := "stern"
	podColor1, containerColor1 := determineColor(podName)
	podColor2, containerColor2 := determineColor(podName)

if podColor1 != podColor2 {
		t.Errorf("expected color for pod to be the same between invocations but was %v and %v",
			podColor1, podColor2)
	}
	if containerColor1 != containerColor2 {
		t.Errorf("expected color for container to be the same between invocations but was %v and %v",
			containerColor1, containerColor2)
	}
}

func TestIsIncludeTestOptions(t *testing.T) {
	msg := "this is a log message"

tests := []struct {
		include  []*regexp.Regexp
		expected bool
	}{
		{
			include:  []*regexp.Regexp{},
			expected: true,
		},
		{
			include: []*regexp.Regexp{
				regexp.MustCompile(`this is not`),
			},
			expected: false,
		},
		{
			include: []*regexp.Regexp{
				regexp.MustCompile(`this is`),
			},
			expected: true,
		},
	}

for i, tt := range tests {
		o := &TailOptions{Include: tt.include}
		if o.IsInclude(msg) != tt.expected {
			t.Errorf("%d: expected %s, but actual %s", i, fmt.Sprint(tt.expected), fmt.Sprint(!tt.expected))
		}
	}
}

func TestUpdateTimezoneAndFormat(t *testing.T) {
	location, _ := time.LoadLocation("Asia/Tokyo")

tests := []struct {
		name     string
		format   string
		message  string
		expected string
		err      string
	}{
		{
			"normal case",
			"", // default format is used if empty
			"2021-04-18T03:54:44.764981564Z",
			"2021-04-18T12:54:44.764981564+09:00",
			"",
		},
		{
			"padding",
			"",
			"2021-04-18T03:54:44.764981500Z",
			"2021-04-18T12:54:44.764981500+09:00",
			"",
		},
		{
			"timestamp required on non timestamp message",
			"",
			"",
			"",
			"missing timestamp",
		},
		{
			"not UTC",
			"",
			"2021-08-03T01:26:29.953994922+02:00",
			"2021-08-03T08:26:29.953994922+09:00",
			"",
		},
		{
			"RFC3339Nano format removed trailing zeros",
			"",
			"2021-06-20T08:20:30.331385Z",
			"2021-06-20T17:20:30.331385000+09:00",
			"",
		},
		{
			"Specified the short format",
			TimestampFormatShort,
			"2021-06-20T08:20:30.331385Z",
			"06-20 17:20:30",
			"",
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tailOptions := &TailOptions{
				Location:        location,
				TimestampFormat: tt.format,
			}

message, err := tailOptions.UpdateTimezoneAndFormat(tt.message)
			if tt.expected != message {
				t.Errorf("expected %q, but actual %q", tt.expected, message)
			}

if err != nil && tt.err != err.Error() {
				t.Errorf("expected %q, but actual %q", tt.err, err)
			}
		})
	}
}

func TestConsumeStreamTail(t *testing.T) {
	logLines := `2023-02-13T21:20:30.000000001Z line 1
2023-02-13T21:20:30.000000002Z line 2
2023-02-13T21:20:31.000000001Z line 3
2023-02-13T21:20:31.000000002Z line 4`
	tmpl := template.Must(template.New("").Parse(`{{printf "%s (%s/%s/%s/%s)\n" .Message .NodeName .Namespace .PodName .ContainerName}}`))

tests := []struct {
		name      string
		resumeReq *ResumeRequest
		expected  []byte
	}{
		{
			name: "normal",
			expected: []byte(`line 1 (my-node/my-namespace/my-pod/my-container)
line 2 (my-node/my-namespace/my-pod/my-container)
line 3 (my-node/my-namespace/my-pod/my-container)
line 4 (my-node/my-namespace/my-pod/my-container)
`),
		},
		{
			name:      "ResumeRequest LinesToSkip=1",
			resumeReq: &ResumeRequest{Timestamp: "2023-02-13T21:20:30Z", LinesToSkip: 1},
			expected: []byte(`line 2 (my-node/my-namespace/my-pod/my-container)
line 3 (my-node/my-namespace/my-pod/my-container)
line 4 (my-node/my-namespace/my-pod/my-container)
`),
		},
		{
			name:      "ResumeRequest LinesToSkip=2",
			resumeReq: &ResumeRequest{Timestamp: "2023-02-13T21:20:30Z", LinesToSkip: 2},
			expected: []byte(`line 3 (my-node/my-namespace/my-pod/my-container)
line 4 (my-node/my-namespace/my-pod/my-container)
`),
		},
		{
			name:      "ResumeRequest LinesToSkip=3 (exceed)",
			resumeReq: &ResumeRequest{Timestamp: "2023-02-13T21:20:30Z", LinesToSkip: 3},
			expected: []byte(`line 3 (my-node/my-namespace/my-pod/my-container)
line 4 (my-node/my-namespace/my-pod/my-container)
`),
		},
		{
			name:      "ResumeRequest does not match",
			resumeReq: &ResumeRequest{Timestamp: "2222-22-22T21:20:30Z", LinesToSkip: 3},
			expected: []byte(`line 1 (my-node/my-namespace/my-pod/my-container)
line 2 (my-node/my-namespace/my-pod/my-container)
line 3 (my-node/my-namespace/my-pod/my-container)
line 4 (my-node/my-namespace/my-pod/my-container)
`),
		},
	}

clientset := fake.NewSimpleClientset()
	for i, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			out := new(bytes.Buffer)
			tail := NewTail(clientset.CoreV1(), "my-node", "my-namespace", "my-pod", "my-container", tmpl, out, io.Discard, &TailOptions{})
			tail.resumeRequest = tt.resumeReq
			if err := tail.ConsumeRequest(context.TODO(), &responseWrapperMock{data: bytes.NewBufferString(logLines)}); err != nil {
				t.Fatalf("%d: unexpected err %v", i, err)
			}

if !bytes.Equal(tt.expected, out.Bytes()) {
				t.Errorf("%d: expected %s, but actual %s", i, tt.expected, out)
			}
		})
	}
}

type responseWrapperMock struct {
	data io.Reader
}

func (r *responseWrapperMock) DoRaw(context.Context) ([]byte, error) {
	data, _ := io.ReadAll(r.data)
	return data, nil
}

func (r *responseWrapperMock) Stream(context.Context) (io.ReadCloser, error) {
	return io.NopCloser(r.data), nil
}

func TestPrintStarting(t *testing.T) {
	tests := []struct {
		options  *TailOptions
		expected []byte
	}{
		{
			&TailOptions{},
			[]byte("+ my-pod › my-container\n"),
		},
		{
			&TailOptions{
				Namespace: true,
			},
			[]byte("+ my-namespace my-pod › my-container\n"),
		},
		{
			&TailOptions{
				OnlyLogLines: true,
			},
			[]byte{},
		},
		{
			&TailOptions{
				Namespace:    true,
				OnlyLogLines: true,
			},
			[]byte{},
		},
	}

clientset := fake.NewSimpleClientset()
	for i, tt := range tests {
		errOut := new(bytes.Buffer)
		tail := NewTail(clientset.CoreV1(), "my-node", "my-namespace", "my-pod", "my-container", nil, io.Discard, errOut, tt.options)
		tail.printStarting()

if !bytes.Equal(tt.expected, errOut.Bytes()) {
			t.Errorf("%d: expected %q, but actual %q", i, tt.expected, errOut)
		}
	}
}

func TestPrintStopping(t *testing.T) {
	tests := []struct {
		options  *TailOptions
		expected []byte
	}{
		{
			&TailOptions{},
			[]byte("- my-pod › my-container\n"),
		},
		{
			&TailOptions{
				Namespace: true,
			},
			[]byte("- my-namespace my-pod › my-container\n"),
		},
		{
			&TailOptions{
				OnlyLogLines: true,
			},
			[]byte{},
		},
		{
			&TailOptions{
				Namespace:    true,
				OnlyLogLines: true,
			},
			[]byte{},
		},
	}

if !bytes.Equal(tt.expected, errOut.Bytes()) {
			t.Errorf("%d: expected %q, but actual %q", i, tt.expected, errOut)
		}
	}
}

func TestResumeRequestShouldSkip(t *testing.T) {
	tests := []struct {
		rr         ResumeRequest
		timestamps []string
		expected   []bool
	}{
		{
			rr:         ResumeRequest{Timestamp: "t1", LinesToSkip: 1},
			timestamps: []string{"t1", "t1"},
			expected:   []bool{true, false},
		},
		{
			rr:         ResumeRequest{Timestamp: "t1", LinesToSkip: 3},
			timestamps: []string{"t1", "t1", "t1", "t1"},
			expected:   []bool{true, true, true, false},
		},
		{
			rr:         ResumeRequest{Timestamp: "t1", LinesToSkip: 3},
			timestamps: []string{"t2", "t2"},
			expected:   []bool{false, false},
		},
	}
	for _, tt := range tests {
		var actual []bool
		for _, ts := range tt.timestamps {
			actual = append(actual, tt.rr.shouldSkip(ts))
		}
		if !reflect.DeepEqual(tt.expected, actual) {
			t.Errorf("expected %v, but actual %v", tt.expected, actual)
		}
	}
}

func TestRemoveSubsecond(t *testing.T) {
	tests := []struct {
		ts       string
		expected string
	}{
		{
			ts:       "2023-02-14T05:36:39.902767599Z",
			expected: "2023-02-14T05:36:39Z",
		},
		{
			ts:       "2023-02-14T05:36:39.1Z",
			expected: "2023-02-14T05:36:39Z",
		},
		{
			ts:       "2023-02-14T05:36:39Z",
			expected: "2023-02-14T05:36:39Z",
		},
		{
			ts:       "1.1",
			expected: "1",
		},
		{
			ts:       "10.1",
			expected: "10",
		},
		{
			ts:       "",
			expected: "",
		},
		{
			ts:       ".",
			expected: ".",
		},
		{
			ts:       ".1",
			expected: "",
		},
	}
	for _, tt := range tests {
		actual := removeSubsecond(tt.ts)
		if tt.expected != actual {
			t.Errorf("expected %v, but actual %v", tt.expected, actual)
		}
	}
}

func TestHighlighIncludedString(t *testing.T) {
	tests := []struct {
		msg      string
		include  []*regexp.Regexp
		expected string
	}{
		{
			"test matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`test`),
			},
			"\x1b[31;1mtest\x1b[0;22m matched",
		},
		{
			"test not-matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`hoge`),
			},
			"test not-matched",
		},
		{
			"test matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`not-matched`),
				regexp.MustCompile(`matched`),
			},
			"test \x1b[31;1mmatched\x1b[0;22m",
		},
		{
			"test multiple matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`multiple`),
				regexp.MustCompile(`matched`),
			},
			"test \x1b[31;1mmultiple\x1b[0;22m \x1b[31;1mmatched\x1b[0;22m",
		},
		{
			"test match on the longer one",
			[]*regexp.Regexp{
				regexp.MustCompile(`match`),
				regexp.MustCompile(`match on the longer one`),
			},
			"test \x1b[31;1mmatch on the longer one\x1b[0;22m",
		},
	}

orig := color.NoColor
	color.NoColor = false
	defer func() {
		color.NoColor = orig
	}()

for i, tt := range tests {
		o := &TailOptions{Include: tt.include}
		actual := o.HighlightMatchedString(tt.msg)
		if actual != tt.expected {
			t.Errorf("%d: expected %q, but actual %q", i, tt.expected, actual)
		}
	}
}

func TestIncludeAndHighlightMatchedString(t *testing.T) {
	tests := []struct {
		msg       string
		include   []*regexp.Regexp
		highlight []*regexp.Regexp
		expected  string
	}{
		{
			"test matched with highlight",
			[]*regexp.Regexp{
				regexp.MustCompile(`test`),
			},
			[]*regexp.Regexp{
				regexp.MustCompile(`highlight`),
			},
			"\x1b[31;1mtest\x1b[0;22m matched with \x1b[31;1mhighlight\x1b[0;22m",
		},
		{
			"test not-matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`hoge`),
			},
			[]*regexp.Regexp{
				regexp.MustCompile(`highlight`),
			},
			"test not-matched",
		},
		{
			"test matched with highlight",
			[]*regexp.Regexp{
				regexp.MustCompile(`not-matched`),
				regexp.MustCompile(`matched`),
			},
			[]*regexp.Regexp{
				regexp.MustCompile(`no-with-highlight`),
				regexp.MustCompile(`with highlight`),
			},
			"test \x1b[31;1mmatched\x1b[0;22m \x1b[31;1mwith highlight\x1b[0;22m",
		},
		{
			"test multiple matched with many highlight",
			[]*regexp.Regexp{
				regexp.MustCompile(`multiple`),
				regexp.MustCompile(`matched`),
			},
			[]*regexp.Regexp{
				regexp.MustCompile(`many`),
				regexp.MustCompile(`highlight`),
			},
			"test \x1b[31;1mmultiple\x1b[0;22m \x1b[31;1mmatched\x1b[0;22m with \x1b[31;1mmany\x1b[0;22m \x1b[31;1mhighlight\x1b[0;22m",
		},
		{
			"test match on the longer one",
			[]*regexp.Regexp{
				regexp.MustCompile(`match`),
				regexp.MustCompile(`match on the longer one`),
			},
			[]*regexp.Regexp{
				regexp.MustCompile(`match`),
				regexp.MustCompile(`match on the longer one`),
			},
			"test \x1b[31;1mmatch on the longer one\x1b[0;22m",
		},
	}

orig := color.NoColor
	color.NoColor = false
	defer func() {
		color.NoColor = orig
	}()

for i, tt := range tests {
		o := &TailOptions{Include: tt.include, Highlight: tt.highlight}
		actual := o.HighlightMatchedString(tt.msg)
		if actual != tt.expected {
			t.Errorf("%d: expected %q, but actual %q", i, tt.expected, actual)
		}
	}
}

func TestHighlightMatchedString(t *testing.T) {
	tests := []struct {
		msg       string
		highlight []*regexp.Regexp
		expected  string
	}{
		{
			"test matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`test`),
			},
			"\x1b[31;1mtest\x1b[0;22m matched",
		},
		{
			"test not-matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`hoge`),
			},
			"test not-matched",
		},
		{
			"test matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`not-matched`),
				regexp.MustCompile(`matched`),
			},
			"test \x1b[31;1mmatched\x1b[0;22m",
		},
		{
			"test multiple matched",
			[]*regexp.Regexp{
				regexp.MustCompile(`multiple`),
				regexp.MustCompile(`matched`),
			},
			"test \x1b[31;1mmultiple\x1b[0;22m \x1b[31;1mmatched\x1b[0;22m",
		},
		{
			"test match on the longer one",
			[]*regexp.Regexp{
				regexp.MustCompile(`match`),
				regexp.MustCompile(`match on the longer one`),
			},
			"test \x1b[31;1mmatch on the longer one\x1b[0;22m",
		},
	}

orig := color.NoColor
	color.NoColor = false
	defer func() {
		color.NoColor = orig
	}()

for i, tt := range tests {
		o := &TailOptions{Highlight: tt.highlight}
		actual := o.HighlightMatchedString(tt.msg)
		if actual != tt.expected {
			t.Errorf("%d: expected %q, but actual %q", i, tt.expected, actual)
		}
	}
}
07070100000031000081A4000000000000000000000001659C910000001631000000000000000000000000000000000000001D00000000stern-1.28.0/stern/target.go//   Copyright 2017 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"fmt"
	"regexp"
	"sync"

corev1 "k8s.io/api/core/v1"
	"k8s.io/klog/v2"
)

// Target is a target to watch
type Target struct {
	Node      string
	Namespace string
	Pod       string
	Container string
}

// GetID returns the ID of the object
func (t *Target) GetID() string {
	return fmt.Sprintf("%s-%s-%s", t.Namespace, t.Pod, t.Container)
}

// targetState holds a last shown container ID
type targetState struct {
	podUID      string
	containerID string
}

// targetFilter is a filter of Target
type targetFilter struct {
	c            targetFilterConfig
	targetStates map[string]*targetState
	mu           sync.RWMutex
}

type targetFilterConfig struct {
	podFilter              *regexp.Regexp
	excludePodFilter       []*regexp.Regexp
	containerFilter        *regexp.Regexp
	containerExcludeFilter []*regexp.Regexp
	initContainers         bool
	ephemeralContainers    bool
	containerStates        []ContainerState
}

func newTargetFilter(c targetFilterConfig) *targetFilter {
	return &targetFilter{
		c:            c,
		targetStates: make(map[string]*targetState),
	}
}

// visit passes filtered Targets to the visitor function
func (f *targetFilter) visit(pod *corev1.Pod, visitor func(t *Target)) {
	// filter by pod
	if !f.c.podFilter.MatchString(pod.Name) {
		return
	}

for _, re := range f.c.excludePodFilter {
		if re.MatchString(pod.Name) {
			return
		}
	}

// filter by container statuses
	var statuses []corev1.ContainerStatus
	if f.c.initContainers {
		// show initContainers first when --no-follow and --max-log-requests 1
		statuses = append(statuses, pod.Status.InitContainerStatuses...)
	}

statuses = append(statuses, pod.Status.ContainerStatuses...)

if f.c.ephemeralContainers {
		statuses = append(statuses, pod.Status.EphemeralContainerStatuses...)
	}

OUTER:
	for _, c := range statuses {
		if !f.c.containerFilter.MatchString(c.Name) {
			continue
		}

for _, re := range f.c.containerExcludeFilter {
			if re.MatchString(c.Name) {
				continue OUTER
			}
		}

t := &Target{
			Node:      pod.Spec.NodeName,
			Namespace: pod.Namespace,
			Pod:       pod.Name,
			Container: c.Name,
		}

if f.shouldAdd(t, string(pod.UID), c) {
			visitor(t)
		}
	}
}

func (f *targetFilter) matchContainerState(state corev1.ContainerState) bool {
	for _, containerState := range f.c.containerStates {
		if containerState.Match(state) {
			return true
		}
	}
	return false
}

func (f *targetFilter) shouldAdd(t *Target, podUID string, cs corev1.ContainerStatus) bool {
	state := stateToString(cs.State)
	containerID := chooseContainerID(cs)

f.mu.Lock()
	last := f.targetStates[t.GetID()]
	f.targetStates[t.GetID()] = &targetState{podUID: podUID, containerID: containerID}
	f.mu.Unlock()

if containerID == "" {
		// does not have a container to retrieve logs
		klog.V(7).InfoS("Container ID is empty", "state", state, "target", t.GetID())
		return false
	}

if last == nil {
		// We filter out only containers that have existed before stern starts by container states.
		// The container state transition skips the "running" when a pod immediately completes,
		// so filtering by container states does not work as expected for newly created containers.
		klog.V(7).InfoS("Container ID has existed before observation",
			"state", state, "target", t.GetID(), "container", containerID)
		return f.matchContainerState(cs.State)
	}

if last.containerID == containerID {
		klog.V(7).InfoS("Container ID is the same",
			"state", state, "target", t.GetID(), "container", containerID)
		return false
	}
	// add a container when the container ID is changed from the last time
	klog.V(7).InfoS("Container ID was changed",
		"state", state, "target", t.GetID(), "container", containerID, "last", last.containerID)
	return true
}

func (f *targetFilter) forget(podUID string) {
	f.mu.Lock()
	defer f.mu.Unlock()
	// delete target states belonging to the pod
	for targetID, state := range f.targetStates {
		if state.podUID == podUID {
			klog.V(7).InfoS("Forget targetState", "target", targetID)
			delete(f.targetStates, targetID)
		}
	}
}

func (f *targetFilter) isActive(t *Target) bool {
	f.mu.RLock()
	defer f.mu.RUnlock()
	last := f.targetStates[t.GetID()]
	return last != nil && last.containerID != ""
}

func chooseContainerID(cs corev1.ContainerStatus) string {
	// This logic is based on kubelet's validateContainerLogStatus
	// https://github.com/kubernetes/kubernetes/blob/v1.26.1/pkg/kubelet/kubelet_pods.go#L1246
	switch {
	case cs.State.Running != nil:
		return cs.ContainerID
	case cs.State.Terminated != nil:
		if cs.State.Terminated.ContainerID != "" {
			return cs.State.Terminated.ContainerID
		}
	}
	lastTerminated := cs.LastTerminationState.Terminated
	if lastTerminated != nil && lastTerminated.ContainerID != "" {
		return lastTerminated.ContainerID
	}
	return ""
}

func stateToString(state corev1.ContainerState) string {
	switch {
	case state.Running != nil:
		return "running"
	case state.Terminated != nil:
		return "terminated"
	case state.Waiting != nil:
		return "waiting"
	}
	return "unknown"
}
07070100000032000081A4000000000000000000000001659C9100000044BD000000000000000000000000000000000000002200000000stern-1.28.0/stern/target_test.gopackage stern

import (
	"reflect"
	"regexp"
	"testing"

corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func TestTargetFilter(t *testing.T) {
	running := corev1.ContainerState{Running: &corev1.ContainerStateRunning{}}
	terminated := corev1.ContainerState{Terminated: &corev1.ContainerStateTerminated{ContainerID: "dummy"}}
	waiting := corev1.ContainerState{Waiting: &corev1.ContainerStateWaiting{}}

createPod := func(node, pod string) *corev1.Pod {
		return &corev1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				Namespace: "ns1",
				Name:      pod,
			},
			Spec: corev1.PodSpec{
				NodeName: node,
			},
			Status: corev1.PodStatus{
				InitContainerStatuses: []corev1.ContainerStatus{
					{Name: "init-container1-running", State: running, ContainerID: "dummy"},
					{Name: "init-container2-terminated", State: terminated},
					{Name: "init-container3-waiting", State: waiting, LastTerminationState: terminated},
				},
				ContainerStatuses: []corev1.ContainerStatus{
					{Name: "container1-running", State: running, ContainerID: "dummy"},
					{Name: "container2-terminated", State: terminated},
					{Name: "container3-waiting", State: waiting, LastTerminationState: terminated},
				},
				EphemeralContainerStatuses: []corev1.ContainerStatus{
					{Name: "ephemeral-container1-running", State: running, ContainerID: "dummy"},
					{Name: "ephemeral-container2-terminated", State: terminated},
					{Name: "ephemeral-container3-waiting", State: waiting, LastTerminationState: terminated},
				},
			},
		}
	}

pods := []*corev1.Pod{
		createPod("node1", "pod1"),
		createPod("node2", "pod2"),
	}

genTarget := func(node, pod, container string) Target {
		return Target{
			Namespace: "ns1",
			Node:      node,
			Pod:       pod,
			Container: container,
		}
	}

tests := []struct {
		name     string
		config   targetFilterConfig
		expected []Target
	}{
		{
			name: "match all",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container1-running"),
				genTarget("node1", "pod1", "init-container2-terminated"),
				genTarget("node1", "pod1", "init-container3-waiting"),
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node1", "pod1", "ephemeral-container1-running"),
				genTarget("node1", "pod1", "ephemeral-container2-terminated"),
				genTarget("node1", "pod1", "ephemeral-container3-waiting"),
				genTarget("node2", "pod2", "init-container1-running"),
				genTarget("node2", "pod2", "init-container2-terminated"),
				genTarget("node2", "pod2", "init-container3-waiting"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
				genTarget("node2", "pod2", "ephemeral-container1-running"),
				genTarget("node2", "pod2", "ephemeral-container2-terminated"),
				genTarget("node2", "pod2", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "filter by podFilter",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`not-matched`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{},
		},
		{
			name: "filter by excludePodFilter",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(``),
				excludePodFilter:       []*regexp.Regexp{regexp.MustCompile(`pod1`)},
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node2", "pod2", "init-container1-running"),
				genTarget("node2", "pod2", "init-container2-terminated"),
				genTarget("node2", "pod2", "init-container3-waiting"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
				genTarget("node2", "pod2", "ephemeral-container1-running"),
				genTarget("node2", "pod2", "ephemeral-container2-terminated"),
				genTarget("node2", "pod2", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "filter by multiple excludePodFilter",
			config: targetFilterConfig{
				podFilter: regexp.MustCompile(``),
				excludePodFilter: []*regexp.Regexp{
					regexp.MustCompile(`not-matched`),
					regexp.MustCompile(`pod2`),
				},
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container1-running"),
				genTarget("node1", "pod1", "init-container2-terminated"),
				genTarget("node1", "pod1", "init-container3-waiting"),
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node1", "pod1", "ephemeral-container1-running"),
				genTarget("node1", "pod1", "ephemeral-container2-terminated"),
				genTarget("node1", "pod1", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "filter by containerFilter",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*container1.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container1-running"),
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "ephemeral-container1-running"),
				genTarget("node2", "pod2", "init-container1-running"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "ephemeral-container1-running"),
			},
		},
		{
			name: "filter by containerExcludeFilter",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: []*regexp.Regexp{regexp.MustCompile(`.*container1.*`)},
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container2-terminated"),
				genTarget("node1", "pod1", "init-container3-waiting"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node1", "pod1", "ephemeral-container2-terminated"),
				genTarget("node1", "pod1", "ephemeral-container3-waiting"),
				genTarget("node2", "pod2", "init-container2-terminated"),
				genTarget("node2", "pod2", "init-container3-waiting"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
				genTarget("node2", "pod2", "ephemeral-container2-terminated"),
				genTarget("node2", "pod2", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "filter by multiple containerExcludeFilter",
			config: targetFilterConfig{
				podFilter:        regexp.MustCompile(`.*`),
				excludePodFilter: nil,
				containerFilter:  regexp.MustCompile(`.*`),
				containerExcludeFilter: []*regexp.Regexp{
					regexp.MustCompile(`.*container1.*`),
					regexp.MustCompile(`init-container2.*`),
				},
				initContainers:      true,
				ephemeralContainers: true,
				containerStates:     []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container3-waiting"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node1", "pod1", "ephemeral-container2-terminated"),
				genTarget("node1", "pod1", "ephemeral-container3-waiting"),
				genTarget("node2", "pod2", "init-container3-waiting"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
				genTarget("node2", "pod2", "ephemeral-container2-terminated"),
				genTarget("node2", "pod2", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "dot not include initContainers",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         false,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node1", "pod1", "ephemeral-container1-running"),
				genTarget("node1", "pod1", "ephemeral-container2-terminated"),
				genTarget("node1", "pod1", "ephemeral-container3-waiting"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
				genTarget("node2", "pod2", "ephemeral-container1-running"),
				genTarget("node2", "pod2", "ephemeral-container2-terminated"),
				genTarget("node2", "pod2", "ephemeral-container3-waiting"),
			},
		},
		{
			name: "dot not include ephemeralContainers",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    false,
				containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container1-running"),
				genTarget("node1", "pod1", "init-container2-terminated"),
				genTarget("node1", "pod1", "init-container3-waiting"),
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "container2-terminated"),
				genTarget("node1", "pod1", "container3-waiting"),
				genTarget("node2", "pod2", "init-container1-running"),
				genTarget("node2", "pod2", "init-container2-terminated"),
				genTarget("node2", "pod2", "init-container3-waiting"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "container2-terminated"),
				genTarget("node2", "pod2", "container3-waiting"),
			},
		},
		{
			name: "match running states",
			config: targetFilterConfig{
				podFilter:              regexp.MustCompile(`.*`),
				excludePodFilter:       nil,
				containerFilter:        regexp.MustCompile(`.*`),
				containerExcludeFilter: nil,
				initContainers:         true,
				ephemeralContainers:    true,
				containerStates:        []ContainerState{RUNNING},
			},
			expected: []Target{
				genTarget("node1", "pod1", "init-container1-running"),
				genTarget("node1", "pod1", "container1-running"),
				genTarget("node1", "pod1", "ephemeral-container1-running"),
				genTarget("node2", "pod2", "init-container1-running"),
				genTarget("node2", "pod2", "container1-running"),
				genTarget("node2", "pod2", "ephemeral-container1-running"),
			},
		},
	}

for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			actual := []Target{}
			for _, pod := range pods {
				filter := newTargetFilter(tt.config)
				filter.visit(pod, func(target *Target) {
					actual = append(actual, *target)
				})
			}

if !reflect.DeepEqual(tt.expected, actual) {
				t.Errorf("expected %v, but actual %v", tt.expected, actual)
			}
		})
	}
}

func TestTargetFilterShouldAdd(t *testing.T) {
	filter := newTargetFilter(targetFilterConfig{
		// matches all
		podFilter:              regexp.MustCompile(`.*`),
		excludePodFilter:       nil,
		containerFilter:        regexp.MustCompile(`.*`),
		containerExcludeFilter: nil,
		initContainers:         true,
		ephemeralContainers:    true,
		containerStates:        []ContainerState{RUNNING, TERMINATED, WAITING},
	})
	createPod := func(cs corev1.ContainerStatus) *corev1.Pod {
		return &corev1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				Namespace: "ns1",
				Name:      "pod1",
				UID:       "uid1",
			},
			Spec: corev1.PodSpec{
				NodeName: "node1",
			},
			Status: corev1.PodStatus{
				ContainerStatuses: []corev1.ContainerStatus{cs},
			},
		}
	}
	genTarget := func(container string) Target {
		return Target{
			Namespace: "ns1",
			Node:      "node1",
			Pod:       "pod1",
			Container: container,
		}
	}
	tests := []struct {
		name     string
		forget   bool
		cs       corev1.ContainerStatus
		expected []Target
	}{
		{
			name:     "empty state should be ignored",
			cs:       corev1.ContainerStatus{Name: "c1"},
			expected: []Target{},
		},
		{
			name: "running container observed the first time",
			cs: corev1.ContainerStatus{
				Name:        "c1",
				ContainerID: "cid1",
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: []Target{genTarget("c1")},
		},
		{
			name: "same container ID should be ignored",
			cs: corev1.ContainerStatus{
				Name:        "c1",
				ContainerID: "cid1",
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: []Target{},
		},
		{
			name: "different container ID can be added",
			cs: corev1.ContainerStatus{
				Name:        "c1",
				ContainerID: "cid2", // changed
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: []Target{genTarget("c1")},
		},
		{
			name:   "forget() allows the same ID ",
			forget: true,
			cs: corev1.ContainerStatus{
				Name:        "c1",
				ContainerID: "cid2",
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: []Target{genTarget("c1")},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.forget {
				filter.forget("uid1")
			}
			actual := []Target{}
			filter.visit(createPod(tt.cs), func(target *Target) {
				actual = append(actual, *target)
			})
			if !reflect.DeepEqual(tt.expected, actual) {
				t.Errorf("expected %v, but actual %v", tt.expected, actual)
			}
		})
	}
}

func TestChooseContainerID(t *testing.T) {
	lastState := corev1.ContainerState{
		Terminated: &corev1.ContainerStateTerminated{
			ContainerID: "last",
		},
	}
	tests := []struct {
		name     string
		cs       corev1.ContainerStatus
		expected string
	}{
		{
			name: "running",
			cs: corev1.ContainerStatus{
				ContainerID:          "current",
				LastTerminationState: lastState,
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: "current",
		},
		{
			name: "running (empty)",
			cs: corev1.ContainerStatus{
				LastTerminationState: lastState,
				State: corev1.ContainerState{
					Running: &corev1.ContainerStateRunning{},
				},
			},
			expected: "",
		},
		{
			name: "terminated (current terminated container)",
			cs: corev1.ContainerStatus{
				ContainerID:          "current",
				LastTerminationState: lastState,
				State: corev1.ContainerState{
					Terminated: &corev1.ContainerStateTerminated{
						ContainerID: "terminated",
					},
				},
			},
			expected: "terminated",
		},
		{
			name: "terminated (last terminated container)",
			cs: corev1.ContainerStatus{
				ContainerID:          "current",
				LastTerminationState: lastState,
				State: corev1.ContainerState{
					Terminated: &corev1.ContainerStateTerminated{},
				},
			},
			expected: "last",
		},
		{
			name: "terminated (empty)",
			cs: corev1.ContainerStatus{
				State: corev1.ContainerState{
					Terminated: &corev1.ContainerStateTerminated{},
				},
			},
			expected: "",
		},
		{
			name: "waiting",
			cs: corev1.ContainerStatus{
				ContainerID:          "current",
				LastTerminationState: lastState,
				State: corev1.ContainerState{
					Waiting: &corev1.ContainerStateWaiting{},
				},
			},
			expected: "last",
		},
		{
			name: "waiting (empty)",
			cs: corev1.ContainerStatus{
				ContainerID: "current", // should be ignored
				State: corev1.ContainerState{
					Waiting: &corev1.ContainerStateWaiting{},
				},
			},
			expected: "",
		},
		{
			name: "no current state with last state",
			cs: corev1.ContainerStatus{
				ContainerID:          "current",
				LastTerminationState: lastState,
			},
			expected: "last",
		},
		{
			name:     "empty state",
			cs:       corev1.ContainerStatus{},
			expected: "",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			actual := chooseContainerID(tt.cs)
			if tt.expected != actual {
				t.Errorf("expected %v, but actual %v", tt.expected, actual)
			}
		})
	}
}
07070100000033000081A4000000000000000000000001659C910000000954000000000000000000000000000000000000001C00000000stern-1.28.0/stern/watch.go//   Copyright 2016 Wercker Holding BV
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.

package stern

import (
	"context"

"github.com/pkg/errors"

corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/watch"
	v1 "k8s.io/client-go/kubernetes/typed/core/v1"
	"k8s.io/client-go/tools/cache"
	watchtools "k8s.io/client-go/tools/watch"
)

// Watch starts listening to Kubernetes events and emits modified
// containers/pods. The result is targets added.
func WatchTargets(ctx context.Context, i v1.PodInterface, labelSelector labels.Selector, fieldSelector fields.Selector, filter *targetFilter) (chan *Target, error) {
	// RetryWatcher will make sure that in case the underlying watcher is
	// closed (e.g. due to API timeout or etcd timeout) it will get restarted
	// from the last point without the consumer even knowing about it.
	watcher, err := watchtools.NewRetryWatcher("1", &cache.ListWatch{
		WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
			return i.Watch(ctx, metav1.ListOptions{LabelSelector: labelSelector.String(), FieldSelector: fieldSelector.String()})
		},
	})
	if err != nil {
		return nil, errors.Wrap(err, "failed to create a watcher")
	}

added := make(chan *Target)
	go func() {
		for {
			select {
			case e := <-watcher.ResultChan():
				if e.Object == nil {
					// Closed because of error
					close(added)
					return
				}

pod, ok := e.Object.(*corev1.Pod)
				if !ok {
					continue
				}

switch e.Type {
				case watch.Added, watch.Modified:
					filter.visit(pod, func(t *Target) {
						added <- t
					})
				case watch.Deleted:
					filter.forget(string(pod.UID))
				}
			case <-ctx.Done():
				watcher.Stop()
				close(added)
				return
			}
		}
	}()

return added, nil
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!431 blocks

Places

File stern-1.28.0.obscpio of Package stern (Revision 7a6235221457354f59a96c207fb8af48)

Places