File kail-0.17.0.obscpio of Package kail

Overview Repositories Revisions Requests Users Attributes Meta

File kail-0.17.0.obscpio of Package kail (Revision 8dee1dba4e9a0350ec7952725eb1a357)

Currently displaying revision 8dee1dba4e9a0350ec7952725eb1a357 , Show latest

07070100000000000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001400000000kail-0.17.0/.github07070100000001000081A4000000000000000000000001654148A100000067000000000000000000000000000000000000002300000000kail-0.17.0/.github/dependabot.ymlversion: 2
updates:
  - package-ecosystem: gomod
    directory: /
    schedule:
      interval: weekly
07070100000002000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001E00000000kail-0.17.0/.github/workflows07070100000003000081A4000000000000000000000001654148A10000041A000000000000000000000000000000000000002500000000kail-0.17.0/.github/workflows/ci.ymlname: release

on:
  push:
    tags:
      - "*"

permissions:
  contents: write

jobs:
  goreleaser:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Set up Go
        uses: actions/setup-go@v3
        with:
          go-version-file: go.mod
          cache: true
      - name: Login to GitHub Container Registry
        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@v4
        with:
          distribution: goreleaser
          version: latest
          args: release --rm-dist
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          HOMEBREW_TAP_GITHUB_TOKEN: ${{ secrets.HOMEBREW_TAP_GITHUB_TOKEN }}
      - name: Update krew-index
        uses: rajatjindal/krew-release-bot@v0.0.43
        with:
          krew_template_file: .krew/tail.yaml
07070100000004000081A4000000000000000000000001654148A100000158000000000000000000000000000000000000002700000000kail-0.17.0/.github/workflows/test.ymlname: test

on:
  push:
    tags:
      - "**"
    branches:
      - master
  pull_request:

permissions:
  contents: read

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v3
        with:
          go-version-file: go.mod
          cache: true
      - run: go test -v ./...
07070100000005000081A4000000000000000000000001654148A100000023000000000000000000000000000000000000001700000000kail-0.17.0/.gitignore/kail*.exe
/kail
/kail-linux
/dist
07070100000006000081A4000000000000000000000001654148A100000A0B000000000000000000000000000000000000001C00000000kail-0.17.0/.goreleaser.ymlproject_name: kail

env:
  - GO111MODULE=on

before:
  hooks:
    - go mod download

builds:
  - main: cmd/kail/main.go
    binary: kail
    goos:
      - darwin
      - linux
      - windows
    goarch:
      - amd64
      - arm64
    goamd64:
      - v1
      - v2
      - v3
    env:
      - CGO_ENABLED=0
    ldflags:
      - -s -w
      - -X github.com/boz/tail/version.Version={{.Tag}}
      - -X github.com/boz/tail/version.Commit={{.ShortCommit}}
      - -X github.com/boz/tail/version.Date={{.Date}}
      - -X github.com/boz/tail/version.BuiltBy=GoReleaser
      - -X github.com/boz/tail/version.OsName={{.Os}}
      - -X github.com/boz/tail/version.PlatformName={{.Arch}}
      - -X main.version={{.Tag}}
      - -X main.commit={{.ShortCommit}}

archives:
  - name_template: '{{ .ProjectName }}_{{ .Tag }}_{{ .Os }}_{{ .Arch }}{{ with .Arm }}v{{ . }}{{ end }}{{ with .Mips }}_{{ . }}{{ end }}{{ if not (eq .Amd64 "v1") }}{{ .Amd64 }}{{ end }}'

brews:
  - tap:
      owner: boz
      name: homebrew-repo
      branch: master
      token: "{{ .Env.HOMEBREW_TAP_GITHUB_TOKEN }}"
    commit_author:
      name: boz
      email: adam.boz@gmail.com
    goamd64: v2
    homepage: "https://github.com/boz/kail"
    description: "kubernetes tail - pod log viewer"
    skip_upload: true

dockers:
  - image_templates:
      - ghcr.io/boz/{{ .ProjectName }}:{{ .Tag }}-amd64
    dockerfile: Dockerfile
    use: buildx
    build_flag_templates:
      - --platform=linux/amd64
      - --label=org.opencontainers.image.title={{ .ProjectName }}
      - --label=org.opencontainers.image.description={{ .ProjectName }}
      - --label=org.opencontainers.image.url=https://github.com/boz/{{ .ProjectName }}
      - --label=org.opencontainers.image.source=https://github.com/boz/{{ .ProjectName }}
      - --label=org.opencontainers.image.version={{ .Tag }}
      - --label=org.opencontainers.image.created={{ time "2006-01-02T15:04:05Z07:00" }}
      - --label=org.opencontainers.image.revision={{ .FullCommit }}
      - --label=org.opencontainers.image.licenses=MIT
docker_manifests:
  - name_template: ghcr.io/boz/{{ .ProjectName }}:{{ .Tag }}
    image_templates:
      - ghcr.io/boz/{{ .ProjectName }}:{{ .Tag }}-amd64
  - name_template: ghcr.io/boz/{{ .ProjectName }}:latest
    image_templates:
      - ghcr.io/boz/{{ .ProjectName }}:{{ .Tag }}-amd64

checksum:
  name_template: "checksums.txt"
snapshot:
  name_template: "{{ .Tag }}-next"
changelog:
  sort: asc
  filters:
    exclude:
      - "^docs:"
      - "^test:"

release:
  github:
    owner: boz
    name: kail
07070100000007000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001200000000kail-0.17.0/.krew07070100000008000081A4000000000000000000000001654148A100000BF5000000000000000000000000000000000000001C00000000kail-0.17.0/.krew/tail.yamlapiVersion: krew.googlecontainertools.github.com/v1alpha2
kind: Plugin
metadata:
  name: tail
spec:
  version: "{{ .TagName }}"
  platforms:
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_darwin_arm64.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: darwin
        arch: arm64
    bin: kail
    files:
    - from: "kail"
      to: "."
    - from: LICENSE.txt
      to: .
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_darwin_amd64v2.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: darwin
        arch: amd64
    bin: kail
    files:
    - from: "kail"
      to: "."
    - from: LICENSE.txt
      to: .
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_linux_arm64.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: linux
        arch: arm64
    bin: kail
    files:
    - from: "kail"
      to: "."
    - from: LICENSE.txt
      to: .
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_linux_amd64v2.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: linux
        arch: amd64
    bin: kail
    files:
    - from: "kail"
      to: "."
    - from: LICENSE.txt
      to: .
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_windows_arm64.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: windows
        arch: arm64
    bin: kail
    files:
      - from: "kail"
        to: "."
      - from: LICENSE.txt
        to: .
  - {{addURIAndSha "https://github.com/boz/kail/releases/download/{{ .TagName }}/kail_{{ .TagName }}_windows_amd64v2.tar.gz" .TagName }}
    selector:
      matchLabels:
        os: windows
        arch: amd64
    bin: kail
    files:
      - from: "kail"
        to: "."
      - from: LICENSE.txt
        to: .
  homepage: https://github.com/boz/kail
  shortDescription: Stream logs from multiple pods and containers using simple, dynamic source selection.
  description: |-
    Kail https://github.com/boz/kail - "Just show me the logs"

Stream logs from all matched containers of all matched pods.  Match pods by service,
    replicaset, deployment, and others.  Adjusts to a changing cluster - pods are
    added and removed from logging as they fall in or out of the selection.

Documentation:

See https://github.com/boz/kail or

$ kubectl tail --help

Usage:

# match all pods
      $ kubectl tail

# match pods in the 'frontend' namespace
      $ kubectl tail --ns staging

# match pods belonging to a replicaset named 'workers' in any namespace.
      $ kubectl tail --rs workers

# match pods belonging to the replicaset named 'workers' only in the 'staging' namespace
      $ kubectl tail --rs staging/workers

# match pods belonging to both the service "frontend" and the deployment "webapp"
      $ kubectl tail --svc frontend --deploy webapp
07070100000009000081A4000000000000000000000001654148A100000094000000000000000000000000000000000000001700000000kail-0.17.0/DockerfileFROM alpine:3.17.3 as alpine_builder
RUN apk --no-cache add ca-certificates
RUN apk --no-cache add tzdata
ENTRYPOINT ["/kail"]
COPY kail /
CMD [""]
0707010000000A000081A4000000000000000000000001654148A10000042E000000000000000000000000000000000000001800000000kail-0.17.0/LICENSE.txtMIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
0707010000000B000081A4000000000000000000000001654148A1000003DA000000000000000000000000000000000000001500000000kail-0.17.0/Makefile
DOCKER_IMAGE ?= kail
DOCKER_REPO  ?= abozanich/$(DOCKER_IMAGE)
DOCKER_TAG   ?= latest

BUILD_ENV = GOOS=linux GOARCH=amd64

GO = GO111MODULE=on go

ifdef TRAVIS
	LDFLAGS += -X main.version=$(TRAVIS_BRANCH) -X main.commit=$(TRAVIS_COMMIT)
endif

build:
	$(GO) build -o kail ./cmd/kail

build-linux:
	$(BUILD_ENV) $(GO) build --ldflags '$(LDFLAGS)'  -o kail-linux ./cmd/kail

test:
	$(GO) test ./...

test-full: build image
	$(GO) test -v -race ./...

image: build-linux
	docker build -t $(DOCKER_IMAGE) .

image-minikube: build-linux
	eval $$(minikube docker-env) && docker build -t $(DOCKER_IMAGE) .

image-push: image
	docker tag $(DOCKER_IMAGE) $(DOCKER_REPO):$(DOCKER_TAG)
	docker push $(DOCKER_REPO):$(DOCKER_TAG)

install-deps:
	$(GO) mod download

release:
	GITHUB_TOKEN=$$GITHUB_REPO_TOKEN goreleaser -f .goreleaser.yml

clean:
	rm kail kail-linux dist 2>/dev/null || true

.PHONY: build build-linux \
	test test-full \
	image image-minikube image-push \
	install-deps \
	clean
0707010000000C000081A4000000000000000000000001654148A1000015A7000000000000000000000000000000000000001600000000kail-0.17.0/README.md# kail: kubernetes tail [![Build Status](https://github.com/boz/kail/actions/workflows/ci.yml/badge.svg)](https://github.com/boz/kail/actions/workflows/ci.yml)

Kubernetes tail.  Streams logs from all containers of all matched pods.  Match pods by service, replicaset, deployment, and others.  Adjusts to a changing cluster - pods are added and removed from logging as they fall in or out of the selection.

[![asciicast](https://asciinema.org/a/133521.png)](https://asciinema.org/a/133521)

## Usage

With no arguments, kail matches all pods in the cluster.  You can control the matching pods with arguments which select pods based on various criteria.

All flags can be set by an environment variable - `KAIL_POD=foo kail` is the same as `kail --pod foo`.

### Selectors

Flag | Selection
--- | ---
`-l, --label LABEL-SELECTOR` | match pods based on a [standard label selector](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/)
`-p, --pod NAME` | match pods by name
`-n, --ns NAMESPACE-NAME` | match pods in the given namespace
`--svc NAME` | match pods belonging to the given service
`--rc NAME` | match pods belonging to the given replication controller
`--rs NAME` | match pods belonging to the given replica set
`-d, --deploy NAME` | match pods belonging to the given deployment
`--sts NAME` | match pods belonging to the given statefulset
`-j, --job NAME` | match pods belonging to the given job
`--node NODE-NAME` | match pods running on the given node
`--ing NAME` | match pods belonging to services targeted by the given ingress
`-c, --containers CONTAINER-NAME` | restrict which containers logs are shown for
`--ignore LABEL-SELECTOR` | Ignore pods that the selector matches. (default: `kail.ignore=true`)
`--current-ns` | Match pods in the namespace specified in Kubernetes' "current context"
`--ignore-ns NAME` | Ignore pods in the given namespaces.  Overridden by `--ns`, `--current-ns`. (default: `kube-system`)

#### Name Selection

When selecting objects by `NAME` (`--svc`, `--pod`, etc...), you can either qualify it with a namespace to restrict the selection to the given namespace, or select across all namespaces by giving just the object name.

Example:

```sh
# match pods belonging to a replicaset named 'workers' in any namespace.
$ kail --rs workers

# match pods belonging to the replicaset named 'workers' only in the 'staging' namespace
$ kail --rs staging/workers
```

#### Combining Selectors

If the same flag is used more than once, the selectors for that flag are "OR"ed together.

```sh
# match pods belonging to a replicaset named "workers" or "db"
$ kail --rs workers --rs db
```

Different flags are "AND"ed together:

```sh
# match pods belonging to both the service "frontend" and the deployment "webapp"
$ kail --svc frontend --deploy webapp
```

### Other Flags

Flag | Description
--- | ---
`-h, --help` | Display help and usage
`--context CONTEXT-NAME` | Use the given Kubernetes context
`--dry-run` | Print initial matched pods and exit
`--log-level LEVEL` | Set the logging level (default: `error`)
`--log-file PATH` | Write output to `PATH` (default: `/dev/stderr`)
`--since DURATION` | Display logs as old as given duration. Ex: `5s`, `2m`, `1.5h` or `2h45m` (defaults: `1s`). See [here](https://golang.org/pkg/time/#ParseDuration) for more information on the duration format.
`-o, --output` | You can choose to display logs in default, raw (without prefix), json, pretty json and zerolog formats.

## Installing

### Homebrew

```sh
$ brew tap boz/repo
$ brew install boz/repo/kail
```

### Krew

```sh
$ kubectl krew install tail
$ kubectl tail -h
```

### Downloading

Kail binaries for Linux and OSX can be found on the [latest release](https://github.com/boz/kail/releases/latest) page.  Download and install into your `$GOPATH/bin`.

### Running in a cluster with `kubectl`

The docker image [abozanich/kail](https://hub.docker.com/r/abozanich/kail/) is available for running `kail` from within a kubernetes pod via `kubectl`.

Note: be sure to include the `kail.ignore=true` label, otherwise... it's logging all the way down.

Example:

```sh
# match all pods - synonymous with 'kail' from the command line
$ kubectl run -it --rm -l kail.ignore=true --restart=Never --image=abozanich/kail kail

# match pods belonging to service 'api' in any namespace - synonymous with 'kail --svc api'
$ kubectl run -it --rm -l kail.ignore=true --restart=Never --image=abozanich/kail kail -- --svc api
```

## Building

### Install build and dev dependencies

* [govendor](https://github.com/kardianos/govendor)
* [minikube](https://minikube.sigs.k8s.io/docs/start/)
* _linux only_: [musl-gcc](https://www.musl-libc.org/how.html) for building docker images.

### Install source code and golang dependencies

```sh
$ go get -d github.com/boz/kail
$ cd $GOPATH/src/github.com/boz/kail
$ make install-deps
```

### Build binary

```sh
$ make
```

### Install run against a demo cluster

```sh
$ minikube start
$ ./_example/demo.sh start
$ ./kail

# install image into minikube and run via kubectl
$ make image-minikube
$ kubectl run -it --rm -l kail.ignore=true --restart=Never --image=kail kail
```

### Stress testing

Start minikube with a fair amount of CPU and memory.

```sh
$ minikube start --cpus 4 --memory 8192
```

Start [`stress.yml`](_example/stress.yml) resources.

```sh
$ kubectl create -f _example/stress.yml
```

Wait a while for the pods to run

```sh
$ kubectl get pods --namespace stress | grep Running | wc -l
100
```

Run kail

```sh
./kail --ns stress
```
0707010000000D000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001500000000kail-0.17.0/_example0707010000000E000081ED000000000000000000000001654148A1000001C5000000000000000000000000000000000000001D00000000kail-0.17.0/_example/demo.sh#!/bin/sh

# ./kail
# ./kail --svc api
# ./kail --svc prod/api -c nginx
# ./kail --rs workers --ns test --ns demo
# ./kail --deploy api -c cache
# ./kail -l 'app=api,component != worker' -c nginx

start() {
  for file in $(dirname $0)/{prod,demo,test}.yml; do
    kubectl create -f "$file"
  done
}

stop() {
  for file in $(dirname $0)/{prod,demo,test}.yml; do
    kubectl delete -f "$file"
  done
}

case "$1" in
  start) start;;
  stop) stop;;
esac

0707010000000F000081A4000000000000000000000001654148A10000013E000000000000000000000000000000000000002100000000kail-0.17.0/_example/echopod.yml---
apiVersion: v1
kind: Pod
metadata:
  name: echopod
spec:
  containers:
  - name: dater
    image: busybox
    command:
    - /bin/sh
    - "-c"
    - while true; do date; sleep 1; done
  - name: doomed
    image: busybox
    command:
    - /bin/sh
    - "-c"
    - for i in $(seq 1 5); do echo "$i"; sleep 1; done
07070100000010000081A4000000000000000000000001654148A1000001F7000000000000000000000000000000000000002100000000kail-0.17.0/_example/echosvc.yml---
apiVersion: v1
kind: ReplicationController
metadata:
  name: echosvc
spec:
  template:
    metadata:
      name: echosvc
      labels:
        component: echosvc
    spec:
      containers:
      - name: busybox
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - while true; do date; sleep 1; done
        ports:
          - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: echosvc
spec:
  selector:
    component: echosvc
  ports:
    - port: 80
07070100000011000081A4000000000000000000000001654148A1000000B8000000000000000000000000000000000000002100000000kail-0.17.0/_example/failpod.yml---
apiVersion: v1
kind: Pod
metadata:
  name: failpod
spec:
  containers:
  - name: buggy
    image: busybox
    command:
    - /bin/sh
    - "-c"
    - date; echo "dying..."; exit 1
07070100000012000081A4000000000000000000000001654148A1000003EC000000000000000000000000000000000000002800000000kail-0.17.0/_example/init-container.yml---
apiVersion: v1
kind: Namespace
metadata:
  name: init-container
---
apiVersion: extensions/v1beta1
kind: ReplicaSet
metadata:
  namespace: init-container
  name: workers
spec:
  selector:
    matchLabels:
      app: api
      tier: backend
      component: worker
  template:
    metadata:
      name: workers
      labels:
        app: api
        tier: backend
        component: worker
    spec:
      initContainers:
      - name: init
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while [ $i -lt 10 ]; do echo "INIT $i"; sleep 1; i=$((i + 1)); done
      containers:
      - name: statistics
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "processing user $1 stats..."; sleep 1; i=$((i + 1)); done
      - name: thumbnails
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "creating user $1 thumbnail..."; sleep 2; i=$((i + 1)); done
07070100000013000081A4000000000000000000000001654148A100000742000000000000000000000000000000000000001E00000000kail-0.17.0/_example/prod.yml---
apiVersion: v1
kind: Namespace
metadata:
  name: prod
---
apiVersion: apps/v1beta2
kind: Deployment
metadata:
  namespace: prod
  name: api
spec:
  replicas: 1
  selector:
    matchLabels:
      app: api
      tier: frontend
  template:
    metadata:
      labels:
        app: api
        tier: frontend
    spec:
      containers:
      - name: nginx
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - |
          i=0;
          while true; do
            echo "GET /users/$i
          no-cache";
            sleep 1;
            i=$((i + 1));
          done
      - name: cache
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "evict users.$i"; sleep 2; i=$((i + 1)); done
---
kind: Service
apiVersion: v1
metadata:
  namespace: prod
  name: api
spec:
  type: NodePort
  selector:
    app: api
    tier: frontend
  ports:
    - protocol: TCP
      port: 4200
      targetPort: http
---
apiVersion: extensions/v1beta1
kind: ReplicaSet
metadata:
  namespace: prod
  name: workers
spec:
  selector:
    matchLabels:
      app: api
      tier: backend
      component: worker
  template:
    metadata:
      name: workers
      labels:
        app: api
        tier: backend
        component: worker
    spec:
      containers:
      - name: statistics
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "processing user $1 stats..."; sleep 1; i=$((i + 1)); done
      - name: thumbnails
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "creating user $1 thumbnail..."; sleep 2; i=$((i + 1)); done
---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  namespace: prod
  name: api
spec:
  backend:
    serviceName: api
    servicePort: 4200
07070100000014000081A4000000000000000000000001654148A100000344000000000000000000000000000000000000002000000000kail-0.17.0/_example/stress.yml---
apiVersion: v1
kind: Namespace
metadata:
  name: stress
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  namespace: stress
  name: api
spec:
  replicas: 100
  template:
    metadata:
      labels:
        app: api
        tier: frontend
    spec:
      containers:
      - name: nginx
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "GET /users/$i"; sleep 1; i=$((i + 1)); done
      - name: cache
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "evict users.$i"; sleep 2; i=$((i + 1)); done
---
kind: Service
apiVersion: v1
metadata:
  namespace: stress
  name: api
spec:
  type: NodePort
  selector:
    app: api
    tier: frontend
  ports:
    - protocol: TCP
      port: 4200
      targetPort: http
07070100000015000081A4000000000000000000000001654148A1000006AA000000000000000000000000000000000000001E00000000kail-0.17.0/_example/test.yml---
apiVersion: v1
kind: Namespace
metadata:
  name: test
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  namespace: test
  name: api
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: api
        tier: frontend
    spec:
      containers:
      - name: nginx
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "GET /users/$i"; sleep 1; i=$((i + 1)); done
      - name: cache
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "evict users.$i"; sleep 2; i=$((i + 1)); done
---
kind: Service
apiVersion: v1
metadata:
  namespace: test
  name: api
spec:
  type: NodePort
  selector:
    app: api
    tier: frontend
  ports:
    - protocol: TCP
      port: 4200
      targetPort: http
---
apiVersion: extensions/v1beta1
kind: ReplicaSet
metadata:
  namespace: test
  name: workers
spec:
  selector:
    matchLabels:
      app: api
      tier: backend
      component: worker
  template:
    metadata:
      name: workers
      labels:
        app: api
        tier: backend
        component: worker
    spec:
      containers:
      - name: statistics
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "processing user $1 stats..."; sleep 1; i=$((i + 1)); done
      - name: thumbnails
        image: busybox
        command:
        - /bin/sh
        - "-c"
        - i=0; while true; do echo "creating user $1 thumbnail..."; sleep 2; i=$((i + 1)); done
---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  namespace: test
  name: api
spec:
  backend:
    serviceName: api
    servicePort: 4200
07070100000016000081A4000000000000000000000001654148A100000403000000000000000000000000000000000000001600000000kail-0.17.0/buffer.gopackage kail

import "bytes"

const bufferMaxRetainSize = logBufsiz

type buffer interface {
	process([]byte) []Event
}

type _buffer struct {
	source EventSource
	prev   *bytes.Buffer
}

func newBuffer(source EventSource) buffer {
	return &_buffer{source, new(bytes.Buffer)}
}

func (b *_buffer) process(log []byte) []Event {

var events []Event

for end := bytes.IndexRune(log, '\n'); end >= 0 && len(log) > 0; end = bytes.IndexRune(log, '\n') {
		var ebuf []byte

if plen := b.prev.Len(); plen > 0 {
			ebuf = make([]byte, plen+end)
			copy(ebuf, b.prev.Bytes())
			copy(ebuf[plen:], log[:end])
			b.prev.Reset()
		} else {
			ebuf = make([]byte, end)
			copy(ebuf, log[:end])
		}

events = append(events, newEvent(b.source, ebuf))
		log = log[end+1:]
	}

if sz := len(log); sz > 0 {
		b.prev.Write(log)
		if plen := b.prev.Len(); plen >= bufferMaxRetainSize {
			ebuf := make([]byte, plen)
			copy(ebuf, b.prev.Bytes())
			events = append(events, newEvent(b.source, ebuf))
			b.prev.Reset()
		}
	}

return events
}
07070100000017000081A4000000000000000000000001654148A1000005C8000000000000000000000000000000000000001B00000000kail-0.17.0/buffer_test.gopackage kail

import (
	"testing"

"github.com/stretchr/testify/assert"
)

func TestBuffer(t *testing.T) {
	source := eventSource{}

{
		buffer := newBuffer(source)
		events := buffer.process([]byte(""))
		assert.Empty(t, events)

events = buffer.process([]byte("foo\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "foo", string(events[0].Log()))
	}

{
		buffer := newBuffer(source)
		events := buffer.process([]byte("foo"))
		assert.Empty(t, events)

events = buffer.process([]byte("\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "foo", string(events[0].Log()))
	}

{
		buffer := newBuffer(source)
		events := buffer.process([]byte("foo\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "foo", string(events[0].Log()))

events = buffer.process([]byte("bar\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "bar", string(events[0].Log()))
	}

{
		buffer := newBuffer(source)
		events := buffer.process([]byte("foo\nbar\n"))
		assert.Len(t, events, 2)
		assert.Equal(t, "foo", string(events[0].Log()))
		assert.Equal(t, "bar", string(events[1].Log()))

events = buffer.process([]byte("baz\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "baz", string(events[0].Log()))
	}

{
		buffer := newBuffer(source)
		events := buffer.process([]byte("foo\nbar"))
		assert.Len(t, events, 1)
		assert.Equal(t, "foo", string(events[0].Log()))

events = buffer.process([]byte("baz\n"))
		assert.Len(t, events, 1)
		assert.Equal(t, "barbaz", string(events[0].Log()))
	}

}
07070100000018000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001000000000kail-0.17.0/cmd07070100000019000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001500000000kail-0.17.0/cmd/kail0707010000001A000081A4000000000000000000000001654148A100002985000000000000000000000000000000000000001D00000000kail-0.17.0/cmd/kail/main.gopackage main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"text/tabwriter"

logutil "github.com/boz/go-logutil"
	logutil_logrus "github.com/boz/go-logutil/logrus"
	"github.com/boz/kail"
	"github.com/boz/kail/writers"
	"github.com/boz/kcache/nsname"
	"github.com/rs/zerolog"
	"github.com/sirupsen/logrus"
	kingpin "gopkg.in/alecthomas/kingpin.v2"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/client-go/kubernetes"
	_ "k8s.io/client-go/plugin/pkg/client/auth"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
)

var (
	version = "master"
	commit  = "unknown"
)

var (
	flagIgnore = kingpin.Flag("ignore", "ignore selector").PlaceHolder("SELECTOR").Default("kail.ignore=true").Strings()

flagLabel       = kingpin.Flag("label", "label").Short('l').PlaceHolder("SELECTOR").Strings()
	flagPod         = kingpin.Flag("pod", "pod").Short('p').PlaceHolder("NAME").Strings()
	flagNs          = kingpin.Flag("ns", "namespace").Short('n').PlaceHolder("NAME").Strings()
	flagIgnoreNs    = kingpin.Flag("ignore-ns", "ignore namespace").PlaceHolder("NAME").Default("kube-system").Strings()
	flagSvc         = kingpin.Flag("svc", "service").PlaceHolder("NAME").Strings()
	flagRc          = kingpin.Flag("rc", "replication controller").PlaceHolder("NAME").Strings()
	flagRs          = kingpin.Flag("rs", "replica set").PlaceHolder("NAME").Strings()
	flagDs          = kingpin.Flag("ds", "daemonset").PlaceHolder("NAME").Strings()
	flagDeployment  = kingpin.Flag("deploy", "deployment").Short('d').PlaceHolder("NAME").Strings()
	flagStatefulSet = kingpin.Flag("sts", "statefulset").PlaceHolder("NAME").Strings()
	flagJob         = kingpin.Flag("job", "job").Short('j').PlaceHolder("NAME").Strings()
	flagNode        = kingpin.Flag("node", "node").PlaceHolder("NAME").Strings()
	flagIng         = kingpin.Flag("ing", "ingress").PlaceHolder("NAME").Strings()

flagContext = kingpin.Flag("context", "kubernetes context").PlaceHolder("CONTEXT-NAME").String()

flagCurrentNS = kingpin.Flag("current-ns", "use namespace from current context").
			Default("false").
			Bool()

flagContainers = kingpin.Flag("containers", "containers").Short('c').PlaceHolder("NAME").Strings()

flagDryRun = kingpin.Flag("dry-run", "print matching pods and exit").
			Default("false").
			Bool()

flagLogFile = kingpin.Flag("log-file", "log file output").
			String()

flagLogLevel = kingpin.Flag("log-level", "log level").
			Default("error").
			Enum("debug", "info", "warn", "error")

flagSince = kingpin.Flag("since", "Display logs generated since given duration, like 5s, 2m, 1.5h or 2h45m. Defaults to 1s.").
			PlaceHolder("DURATION").
			Default("1s").
			Duration()

flagOutput = kingpin.Flag("output", "Log output mode (default, raw, json, or json-pretty, zerolog)").
			Short('o').
			PlaceHolder("default").
			Default("default").
			String()

flagZerologTimestampFieldName = kingpin.Flag("zerolog-timestamp-field", "sets the zerolog timestamp field name, works with --output=zerolog").
					Default("time").
					String()
	flagZerologLevelFieldName = kingpin.Flag("zerolog-level-field", "sets the zerolog level field name, works with --output=zerolog").
					Default("level").
					String()
	flagZerologMessageFieldName = kingpin.Flag("zerolog-message-field", "sets the zerolog message field name, works with --output=zerolog").
					Default("message").
					String()
	flagZerologErrorFieldName = kingpin.Flag("zerolog-error-field", "sets the zerolog error field name, works with --output=zerolog").
					Default("error").
					String()
)

var (
	currentNS = ""
)

func main() {

// XXX: hack to make kubectl run work
	if os.Args[len(os.Args)-1] == "" {
		os.Args = os.Args[0 : len(os.Args)-1]
	}

kingpin.Command("run", "Display logs").Default()
	kingpin.Command("version", "Display current version")
	kingpin.CommandLine.HelpFlag.Short('h')
	kingpin.CommandLine.Help = "Tail for kubernetes pods"
	kingpin.CommandLine.DefaultEnvars()
	cmd := kingpin.Parse()

if cmd == "version" {
		showVersion()
		return
	}

log := createLog()

dsb := createDSBuilder()

ctx := logutil.NewContext(context.Background(), log)

ctx, cancel := context.WithCancel(ctx)

cs, rc := createKubeClient(ctx)

sigch := watchSignals(ctx, cancel)

ds := createDS(ctx, cs, dsb)

filter := kail.NewContainerFilter(*flagContainers)

if *flagDryRun {

listPods(ds, filter)

} else {

streamLogs(createController(ctx, cs, rc, ds, filter))

}

cancel()
	<-ds.Done()
	<-sigch
}

func showVersion() {
	fmt.Printf("%s (%s)\n", version, commit)
	return
}

func watchSignals(ctx context.Context, cancel context.CancelFunc) <-chan struct{} {
	donech := make(chan struct{})
	sigch := make(chan os.Signal, 1)
	signal.Notify(sigch, syscall.SIGINT, syscall.SIGHUP)
	go func() {
		defer close(donech)
		defer signal.Stop(sigch)
		select {
		case <-ctx.Done():
		case <-sigch:
			cancel()
		}
	}()
	return donech
}

func createLog() logutil.Log {
	lvl, err := logrus.ParseLevel(*flagLogLevel)
	kingpin.FatalIfError(err, "Invalid log level")

parent := logrus.New()
	parent.Level = lvl

if *flagLogFile != "" {
		file, err := os.OpenFile(*flagLogFile, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
		kingpin.FatalIfError(err, "Error opening log file")
		parent.Out = file
	} else {
		parent.Out = os.Stderr
	}

return logutil_logrus.New(parent).WithComponent("kail.main")
}

func createKubeClient(ctx context.Context) (kubernetes.Interface, *rest.Config) {

config, err := rest.InClusterConfig()
	switch {
	case err == nil:
		cs, err := kubernetes.NewForConfig(config)
		kingpin.FatalIfError(err, "Error configuring kubernetes connection")
		return cs, config
	case config != nil:
		kingpin.Fatalf("Error configuring in-cluster config: %v", err)
	}

overrides := &clientcmd.ConfigOverrides{}
	if flagContext != nil {
		overrides.CurrentContext = *flagContext
	}

cc := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
		clientcmd.NewDefaultClientConfigLoadingRules(), overrides)

if *flagCurrentNS {
		ns, _, err := cc.Namespace()
		kingpin.FatalIfError(err, "Error determining current namespace")
		currentNS = ns
	}

rc, err := cc.ClientConfig()
	kingpin.FatalIfError(err, "Error determining client config")

cs, err := kubernetes.NewForConfig(rc)
	kingpin.FatalIfError(err, "Error building kubernetes config")

_, err = cs.CoreV1().Namespaces().List(ctx, metav1.ListOptions{})
	if err != nil && !apierrors.IsForbidden(err) {
		kingpin.FatalIfError(err, "Can't connnect to kubernetes")
	}

return cs, rc
}

func createDSBuilder() kail.DSBuilder {
	dsb := kail.NewDSBuilder()

if selectors := parseLabels("ignore", *flagIgnore); len(selectors) > 0 {
		dsb = dsb.WithIgnore(selectors...)
	}

if selectors := parseLabels("selector", *flagLabel); len(selectors) > 0 {
		dsb = dsb.WithSelectors(selectors...)
	}

if ids := parseIds("pod", *flagPod); len(ids) > 0 {
		dsb = dsb.WithPods(ids...)
	}

if *flagCurrentNS && currentNS != "" {
		dsb = dsb.WithNamespace(currentNS)
	}

if len(*flagNs) > 0 {
		dsb = dsb.WithNamespace(*flagNs...)
	}

if len(*flagIgnoreNs) > 0 {
		dsb = dsb.WithIgnoreNamespace(*flagIgnoreNs...)
	}

if ids := parseIds("service", *flagSvc); len(ids) > 0 {
		dsb = dsb.WithService(ids...)
	}

if len(*flagNode) > 0 {
		dsb = dsb.WithNode(*flagNode...)
	}

if ids := parseIds("rc", *flagRc); len(ids) > 0 {
		dsb = dsb.WithRC(ids...)
	}

if ids := parseIds("rs", *flagRs); len(ids) > 0 {
		dsb = dsb.WithRS(ids...)
	}

if ids := parseIds("ds", *flagDs); len(ids) > 0 {
		dsb = dsb.WithDS(ids...)
	}

if ids := parseIds("deploy", *flagDeployment); len(ids) > 0 {
		dsb = dsb.WithDeployment(ids...)
	}

if ids := parseIds("sts", *flagStatefulSet); len(ids) > 0 {
		dsb = dsb.WithStatefulSet(ids...)
	}

if ids := parseIds("job", *flagJob); len(ids) > 0 {
		dsb = dsb.WithJob(ids...)
	}

if ids := parseIds("ing", *flagIng); len(ids) > 0 {
		dsb = dsb.WithIngress(ids...)
	}

return dsb
}

func createDS(ctx context.Context, cs kubernetes.Interface, dsb kail.DSBuilder) kail.DS {
	ds, err := dsb.Create(ctx, cs)
	kingpin.FatalIfError(err, "Error creating datasource")

select {
	case <-ds.Ready():
	case <-ds.Done():
		kingpin.Fatalf("Unable to initialize data source")
	}
	return ds
}

func listPods(ds kail.DS, filter kail.ContainerFilter) {
	pods, err := ds.Pods().Cache().List()
	kingpin.FatalIfError(err, "Error fetching pods")

w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

fmt.Fprintln(w, "NAMESPACE\tNAME\tCONTAINER\tNODE")

for _, pod := range pods {
		_, sources := kail.SourcesForPod(filter, pod)
		for _, source := range sources {
			fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", source.Namespace(), source.Name(), source.Container(), source.Node())
		}
	}

w.Flush()
}

func createController(
	ctx context.Context, cs kubernetes.Interface, rc *rest.Config, ds kail.DS, filter kail.ContainerFilter) kail.Controller {

controller, err := kail.NewController(ctx, cs, rc, ds.Pods(), filter, *flagSince)
	kingpin.FatalIfError(err, "Error creating controller")

return controller
}

func streamLogs(controller kail.Controller) {
	var writer writers.Writer

switch *flagOutput {
	case "default":
		writer = writers.NewWriter(os.Stdout)
	case "raw":
		writer = writers.NewRawWriter(os.Stdout)
	case "json":
		writer = writers.NewJSONWriter(os.Stdout)
	case "json-pretty":
		writer = writers.NewJSONPrettyWriter(os.Stdout)
	case "zerolog":
		zerolog.TimestampFieldName = *flagZerologTimestampFieldName
		zerolog.LevelFieldName = *flagZerologLevelFieldName
		zerolog.MessageFieldName = *flagZerologMessageFieldName
		zerolog.ErrorFieldName = *flagZerologErrorFieldName
		writer = writers.NewZerologWriter(os.Stdout)
	default:
		kingpin.Fatalf("Invalid output: '%v'", *flagOutput)
	}

for {
		select {
		case ev := <-controller.Events():
			writer.Print(ev)
		case <-controller.Done():
			return
		}
	}
}

func parseLabels(name string, vals []string) []labels.Selector {
	var selectors []labels.Selector
	for _, val := range vals {
		selector, err := labels.Parse(val)
		kingpin.FatalIfError(err, "invalid %v labels expression: '%v'", name, val)
		selectors = append(selectors, selector)
	}
	return selectors
}

func parseIds(name string, vals []string) []nsname.NSName {
	var ids []nsname.NSName

for _, val := range vals {
		parts := strings.Split(val, "/")
		switch len(parts) {
		case 2:
			ids = append(ids, nsname.New(parts[0], parts[1]))
		case 1:
			ids = append(ids, nsname.New("", parts[0]))
		default:
			kingpin.Fatalf("Invalid %v name: '%v'", name, val)
		}
	}

return ids
}
0707010000001B000081A4000000000000000000000001654148A100001252000000000000000000000000000000000000001A00000000kail-0.17.0/controller.gopackage kail

import (
	"context"
	"time"

"k8s.io/api/core/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"

lifecycle "github.com/boz/go-lifecycle"
	logutil "github.com/boz/go-logutil"
	"github.com/boz/kcache"
	"github.com/boz/kcache/nsname"
	"github.com/boz/kcache/types/pod"
)

const (
	eventBufsiz = 500
)

type Controller interface {
	Events() <-chan Event
	Close()
	Done() <-chan struct{}
}

func NewController(
	ctx context.Context,
	cs kubernetes.Interface,
	rc *rest.Config,
	pcontroller pod.Controller,
	filter ContainerFilter,
	since time.Duration) (Controller, error) {

pods, err := pcontroller.Subscribe()
	if err != nil {
		return nil, err
	}

initial, err := pods.Cache().List()
	if err != nil {
		pods.Close()
		return nil, err
	}

lc := lifecycle.New()
	go lc.WatchContext(ctx)

log := logutil.FromContextOrDefault(ctx)
	log = log.WithComponent("kail.controller")

c := &controller{
		cs:        cs,
		rc:        rc,
		pods:      pods,
		filter:    filter,
		mconfig:   monitorConfig{since: since},
		eventch:   make(chan Event, eventBufsiz),
		monitorch: make(chan eventSource),
		monitors:  make(map[nsname.NSName]podMonitors),
		log:       log,
		ctx:       ctx,
		lc:        lc,
	}

go c.run(initial)

return c, nil
}

type controller struct {
	cs     kubernetes.Interface
	rc     *rest.Config
	pods   pod.Subscription
	filter ContainerFilter

eventch   chan Event
	monitorch chan eventSource

monitors monitors
	mconfig  monitorConfig

log logutil.Log
	ctx context.Context
	lc  lifecycle.Lifecycle
}

type podMonitors map[eventSource]monitor
type monitors map[nsname.NSName]podMonitors

func (c *controller) Events() <-chan Event {
	return c.eventch
}

func (c *controller) Done() <-chan struct{} {
	return c.lc.Done()
}

func (c *controller) Close() {
	c.lc.Shutdown(nil)
}

func (c *controller) run(initial []*v1.Pod) {
	defer c.log.Un(c.log.Trace("run"))
	defer c.lc.ShutdownCompleted()

peventch := c.pods.Events()
	shutdownch := c.lc.ShutdownRequest()
	draining := false

c.createInitialMonitors(initial)

for {

c.log.Debugf("loop draining:%v monitors:%v", draining, len(c.monitors))

if draining && len(c.monitors) == 0 {
			break
		}

select {

case err := <-shutdownch:
			c.log.Debugf("shutdown requested: %v", err)

c.lc.ShutdownInitiated(err)
			shutdownch = nil
			draining = true

case ev, ok := <-peventch:
			if !ok {
				c.log.Debugf("pods closed")

peventch = nil

if !draining {
					c.lc.ShutdownInitiated(nil)
					shutdownch = nil
					draining = true
				}

break
			}

if !draining {
				c.handlePodEvent(ev)
			}

case source := <-c.monitorch:
			if pms, ok := c.monitors[source.id]; ok {
				if _, ok := pms[source]; ok {
					c.log.Debugf("removing source %v", source)
					delete(pms, source)
					if len(pms) == 0 {
						c.log.Debugf("removing pod %v", source.id)
						delete(c.monitors, source.id)
					}
					break
				}
			}
			c.log.Warnf("attempted to remove unknown source: %v", source)
		}
	}

c.pods.Close()
	<-c.pods.Done()
}

func (c *controller) handlePodEvent(ev pod.Event) {
	pod := ev.Resource()
	id := nsname.ForObject(pod)

c.log.Debugf("event %v %v/%v",
		ev.Type(), ev.Resource().GetName(), ev.Resource().GetNamespace())

if ev.Type() == kcache.EventTypeDelete {
		if pms, ok := c.monitors[id]; ok {
			for _, pm := range pms {
				pm.Shutdown()
			}
		}
		return
	}

c.ensureMonitorsForPod(pod)
}

func (c *controller) ensureMonitorsForPod(pod *v1.Pod) {
	id, sources := sourcesForPod(c.filter, pod)

c.log.Debugf("pod %v/%v: %v containers ready",
		pod.GetNamespace(), pod.GetName(), len(sources))

// delete monitors of not-ready containers
	if pms, ok := c.monitors[id]; ok {
		for source, pm := range pms {
			if !sources[source] {
				pm.Shutdown()
			}
		}
	}

if len(sources) == 0 {
		return
	}

pms, ok := c.monitors[id]
	if !ok {
		pms = make(map[eventSource]monitor)
	}

for source, _ := range sources {
		if _, ok := pms[source]; ok {
			continue
		}
		pms[source] = c.createMonitor(source)
	}

c.monitors[id] = pms
}

func (c *controller) createMonitor(source eventSource) monitor {
	defer c.log.Un(c.log.Trace("createMonitor(%v)", source))

m := newMonitor(c, &source, c.mconfig)

go func() {

select {
		case <-m.Done():
		case <-c.lc.ShuttingDown():
			m.Shutdown()
			<-m.Done()
		}

select {
		case c.monitorch <- source:
		case <-c.lc.Done():
			c.log.Warnf("done before monitor %v unregistered", source)
		}
	}()

return m
}

func (c *controller) createInitialMonitors(pods []*v1.Pod) {
	defer c.log.Un(c.log.Trace("createInitialMonitors(pods=%v)", len(pods)))
	for _, pod := range pods {
		c.ensureMonitorsForPod(pod)
	}
}
0707010000001C000081A4000000000000000000000001654148A100000AF7000000000000000000000000000000000000001200000000kail-0.17.0/ds.gopackage kail

import (
	"context"

logutil "github.com/boz/go-logutil"
	"github.com/boz/kcache/types/daemonset"
	"github.com/boz/kcache/types/deployment"
	"github.com/boz/kcache/types/ingress"
	"github.com/boz/kcache/types/job"
	"github.com/boz/kcache/types/node"
	"github.com/boz/kcache/types/pod"
	"github.com/boz/kcache/types/replicaset"
	"github.com/boz/kcache/types/replicationcontroller"
	"github.com/boz/kcache/types/service"
	"github.com/boz/kcache/types/statefulset"
)

type DS interface {
	Pods() pod.Controller
	Ready() <-chan struct{}
	Done() <-chan struct{}
	Close()
}

type datastore struct {
	podBase         pod.Controller
	servicesBase    service.Controller
	nodesBase       node.Controller
	rcsBase         replicationcontroller.Controller
	rssBase         replicaset.Controller
	dssBase         daemonset.Controller
	deploymentsBase deployment.Controller
	statefulsetBase statefulset.Controller
	jobsBase        job.Controller
	ingressesBase   ingress.Controller

pods         pod.Controller
	services     service.Controller
	nodes        node.Controller
	rcs          replicationcontroller.Controller
	rss          replicaset.Controller
	dss          daemonset.Controller
	deployments  deployment.Controller
	statefulsets statefulset.Controller
	jobs         job.Controller
	ingresses    ingress.Controller

readych chan struct{}
	donech  chan struct{}
	log     logutil.Log
}

type cacheController interface {
	Close()
	Done() <-chan struct{}
	Ready() <-chan struct{}
}

func (ds *datastore) Pods() pod.Controller {
	return ds.pods
}

func (ds *datastore) Ready() <-chan struct{} {
	return ds.readych
}

func (ds *datastore) Done() <-chan struct{} {
	return ds.donech
}

func (ds *datastore) Close() {
	ds.closeAll()
}

func (ds *datastore) run(ctx context.Context) {
	go func() {
		select {
		case <-ctx.Done():
			ds.Close()
		case <-ds.Done():
		}
	}()

go ds.waitReadyAll()
	go ds.waitDoneAll()
}

func (ds *datastore) waitReadyAll() {
	for _, c := range ds.controllers() {
		select {
		case <-c.Done():
			return
		case <-c.Ready():
		}
	}
	close(ds.readych)
}

func (ds *datastore) closeAll() {
	for _, c := range ds.controllers() {
		c.Close()
	}
}

func (ds *datastore) waitDoneAll() {
	defer close(ds.donech)
	for _, c := range ds.controllers() {
		<-c.Done()
	}
}

func (ds *datastore) controllers() []cacheController {

potential := []cacheController{
		ds.podBase,
		ds.servicesBase,
		ds.nodesBase,
		ds.rcsBase,
		ds.rssBase,
		ds.dssBase,
		ds.deploymentsBase,
		ds.statefulsetBase,
		ds.ingressesBase,
		ds.pods,
		ds.services,
		ds.nodes,
		ds.rcs,
		ds.rss,
		ds.dss,
		ds.deployments,
		ds.statefulsets,
		ds.ingresses,
	}

var existing []cacheController
	for _, c := range potential {
		if c != nil {
			existing = append(existing, c)
		}
	}
	return existing
}
0707010000001D000081A4000000000000000000000001654148A100002992000000000000000000000000000000000000001A00000000kail-0.17.0/ds_builder.gopackage kail

import (
	"context"

"github.com/boz/kcache/types/job"

logutil "github.com/boz/go-logutil"
	"github.com/boz/kcache/filter"
	"github.com/boz/kcache/join"
	"github.com/boz/kcache/nsname"
	"github.com/boz/kcache/types/daemonset"
	"github.com/boz/kcache/types/deployment"
	"github.com/boz/kcache/types/ingress"
	"github.com/boz/kcache/types/pod"
	"github.com/boz/kcache/types/replicaset"
	"github.com/boz/kcache/types/replicationcontroller"
	"github.com/boz/kcache/types/service"
	"github.com/boz/kcache/types/statefulset"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/client-go/kubernetes"
)

type DSBuilder interface {
	WithIgnore(selectors ...labels.Selector) DSBuilder
	WithSelectors(selectors ...labels.Selector) DSBuilder
	WithPods(id ...nsname.NSName) DSBuilder
	WithNamespace(name ...string) DSBuilder
	WithIgnoreNamespace(name ...string) DSBuilder
	WithService(id ...nsname.NSName) DSBuilder
	WithNode(name ...string) DSBuilder
	WithRC(id ...nsname.NSName) DSBuilder
	WithRS(id ...nsname.NSName) DSBuilder
	WithDS(id ...nsname.NSName) DSBuilder
	WithDeployment(id ...nsname.NSName) DSBuilder
	WithStatefulSet(id ...nsname.NSName) DSBuilder
	WithJob(id ...nsname.NSName) DSBuilder
	WithIngress(id ...nsname.NSName) DSBuilder

Create(ctx context.Context, cs kubernetes.Interface) (DS, error)
}

func NewDSBuilder() DSBuilder {
	return &dsBuilder{}
}

type dsBuilder struct {
	ignore       []labels.Selector
	selectors    []labels.Selector
	pods         []nsname.NSName
	namespaces   []string
	ignoreNS     []string
	services     []nsname.NSName
	nodes        []string
	rcs          []nsname.NSName
	rss          []nsname.NSName
	dss          []nsname.NSName
	deployments  []nsname.NSName
	statefulsets []nsname.NSName
	jobs         []nsname.NSName
	ingresses    []nsname.NSName
}

func (b *dsBuilder) WithIgnore(selector ...labels.Selector) DSBuilder {
	b.ignore = append(b.ignore, selector...)
	return b
}

func (b *dsBuilder) WithSelectors(selectors ...labels.Selector) DSBuilder {
	b.selectors = append(b.selectors, selectors...)
	return b
}

func (b *dsBuilder) WithPods(id ...nsname.NSName) DSBuilder {
	b.pods = append(b.pods, id...)
	return b
}

func (b *dsBuilder) WithNamespace(name ...string) DSBuilder {
	b.namespaces = append(b.namespaces, name...)
	return b
}

func (b *dsBuilder) WithIgnoreNamespace(name ...string) DSBuilder {
	b.ignoreNS = append(b.ignoreNS, name...)
	return b
}

func (b *dsBuilder) WithService(id ...nsname.NSName) DSBuilder {
	b.services = append(b.services, id...)
	return b
}

func (b *dsBuilder) WithNode(name ...string) DSBuilder {
	b.nodes = append(b.nodes, name...)
	return b
}

func (b *dsBuilder) WithRC(id ...nsname.NSName) DSBuilder {
	b.rcs = append(b.rcs, id...)
	return b
}

func (b *dsBuilder) WithRS(id ...nsname.NSName) DSBuilder {
	b.rss = append(b.rss, id...)
	return b
}

func (b *dsBuilder) WithDS(id ...nsname.NSName) DSBuilder {
	b.dss = append(b.dss, id...)
	return b
}

func (b *dsBuilder) WithDeployment(id ...nsname.NSName) DSBuilder {
	b.deployments = append(b.deployments, id...)
	return b
}

func (b *dsBuilder) WithStatefulSet(id ...nsname.NSName) DSBuilder {
	b.statefulsets = append(b.statefulsets, id...)
	return b
}

func (b *dsBuilder) WithJob(id ...nsname.NSName) DSBuilder {
	b.jobs = append(b.jobs, id...)
	return b
}

func (b *dsBuilder) WithIngress(id ...nsname.NSName) DSBuilder {
	b.ingresses = append(b.ingresses, id...)
	return b
}

func (b *dsBuilder) Create(ctx context.Context, cs kubernetes.Interface) (DS, error) {
	log := logutil.FromContextOrDefault(ctx)

ds := &datastore{
		readych: make(chan struct{}),
		donech:  make(chan struct{}),
		log:     log.WithComponent("kail.ds"),
	}

log = log.WithComponent("kail.ds.builder")

namespace := ""
	// if we only ask for one namespace do not try to get resources at cluster level
	// we may not have permissions
	// but if the namespace does not exist (or any other problem) we watch namespaces to wait for it
	if len(b.namespaces) == 1 {
		namespace = b.namespaces[0]
		_, err := cs.CoreV1().Namespaces().Get(ctx, namespace, metav1.GetOptions{})
		if err != nil {
			log.Warnf("could not tail the namespace %s: %v", namespace, err)
			namespace = ""
		}
	}
	base, err := pod.NewController(ctx, log, cs, namespace)
	if err != nil {
		return nil, log.Err(err, "base pod controller")
	}

ds.podBase = base
	ds.pods, err = base.CloneWithFilter(filter.Null())
	if err != nil {
		ds.closeAll()
		return nil, log.Err(err, "null filter")
	}

if len(b.ignore) != 0 {
		filters := make([]filter.Filter, 0, len(b.ignore))
		for _, selector := range b.ignore {
			filters = append(filters, filter.Not(filter.Selector(selector)))
		}
		ds.pods, err = ds.pods.CloneWithFilter(filter.And(filters...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "labels filter")
		}
	}

if len(b.selectors) != 0 {
		filters := make([]filter.Filter, 0, len(b.selectors))
		for _, selector := range b.selectors {
			filters = append(filters, filter.Selector(selector))
		}
		ds.pods, err = ds.pods.CloneWithFilter(filter.And(filters...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "labels filter")
		}
	}

if len(b.pods) != 0 {
		ds.pods, err = ds.pods.CloneWithFilter(filter.NSName(b.pods...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "pods filter")
		}
	}

namespaces := make(map[string]bool, len(b.namespaces))

if sz := len(b.namespaces); sz > 0 {
		ids := make([]nsname.NSName, 0, sz)
		for _, ns := range b.namespaces {
			namespaces[ns] = true
			ids = append(ids, nsname.New(ns, ""))
		}

ds.pods, err = ds.pods.CloneWithFilter(filter.NSName(ids...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "namespace filter")
		}
	}

if sz := len(b.ignoreNS); sz > 0 {
		ids := make([]nsname.NSName, 0, sz)
		for _, ns := range b.ignoreNS {
			if !namespaces[ns] {
				ids = append(ids, nsname.New(ns, ""))
			}
		}

ds.pods, err = ds.pods.CloneWithFilter(filter.Not(filter.NSName(ids...)))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ignore namespace filter")
		}
	}

if len(b.nodes) != 0 {
		ds.pods, err = ds.pods.CloneWithFilter(pod.NodeFilter(b.nodes...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "node filter")
		}
	}

if len(b.services) != 0 {
		ds.servicesBase, err = service.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "service base controller")
		}

ds.services, err = ds.servicesBase.CloneWithFilter(filter.NSName(b.services...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "service controller")
		}

ds.pods, err = join.ServicePods(ctx, ds.services, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "service join")
		}
	}

if len(b.rcs) != 0 {
		ds.rcsBase, err = replicationcontroller.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rc base controller")
		}

ds.rcs, err = ds.rcsBase.CloneWithFilter(filter.NSName(b.rcs...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rc controller")
		}

ds.pods, err = join.RCPods(ctx, ds.rcs, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rc join")
		}
	}

if len(b.rss) != 0 {
		ds.rssBase, err = replicaset.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rs base controller")
		}

ds.rss, err = ds.rssBase.CloneWithFilter(filter.NSName(b.rss...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rs controller")
		}

ds.pods, err = join.RSPods(ctx, ds.rss, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "rs join")
		}
	}

if len(b.dss) != 0 {
		ds.dssBase, err = daemonset.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ds base controller")
		}

ds.dss, err = ds.dssBase.CloneWithFilter(filter.NSName(b.dss...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ds controller")
		}

ds.pods, err = join.DaemonSetPods(ctx, ds.dss, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ds join")
		}
	}

if len(b.deployments) != 0 {
		ds.deploymentsBase, err = deployment.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "deployment base controller")
		}

ds.deployments, err = ds.deploymentsBase.CloneWithFilter(filter.NSName(b.deployments...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "deployment controller")
		}

ds.pods, err = join.DeploymentPods(ctx, ds.deployments, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "deployment join")
		}
	}

if len(b.statefulsets) != 0 {
		ds.statefulsetBase, err = statefulset.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "statefulset base controller")
		}

ds.statefulsets, err = ds.statefulsetBase.CloneWithFilter(filter.NSName(b.statefulsets...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "statefulset controller")
		}

ds.pods, err = join.StatefulSetPods(ctx, ds.statefulsets, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "statefulset join")
		}
	}

if len(b.jobs) != 0 {
		ds.jobsBase, err = job.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "job base controller")
		}

ds.jobs, err = ds.jobsBase.CloneWithFilter(filter.NSName(b.jobs...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "job controller")
		}

ds.pods, err = join.JobPods(ctx, ds.jobs, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "job join")
		}
	}

if len(b.ingresses) != 0 {
		ds.ingressesBase, err = ingress.NewController(ctx, log, cs, namespace)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ingress base controller")
		}

if ds.servicesBase == nil {
			ds.servicesBase, err = service.NewController(ctx, log, cs, namespace)
			if err != nil {
				ds.closeAll()
				return nil, log.Err(err, "service base controller")
			}
			ds.services = ds.servicesBase
		}

ds.ingresses, err = ds.ingressesBase.CloneWithFilter(filter.NSName(b.ingresses...))
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ingresses controller")
		}

ds.pods, err = join.IngressPods(ctx, ds.ingresses, ds.services, ds.pods)
		if err != nil {
			ds.closeAll()
			return nil, log.Err(err, "ingress join")
		}
	}

ds.run(ctx)

return ds, nil
}
0707010000001E000081A4000000000000000000000001654148A100000615000000000000000000000000000000000000001600000000kail-0.17.0/filter.gopackage kail

import (
	"sort"

"github.com/boz/kcache/nsname"
	"k8s.io/api/core/v1"
)

type ContainerFilter interface {
	Accept(cs v1.ContainerStatus) bool
}

func NewContainerFilter(names []string) ContainerFilter {
	return containerFilter(names)
}

type containerFilter []string

func (cf containerFilter) Accept(cs v1.ContainerStatus) bool {
	if cs.State.Running == nil && cs.State.Terminated == nil {
		return false
	}
	if len(cf) == 0 {
		return true
	}
	for _, name := range cf {
		if name == cs.Name {
			return true
		}
	}
	return false
}

func sourcesForPod(filter ContainerFilter, pod *v1.Pod) (nsname.NSName, map[eventSource]bool) {
	id := nsname.ForObject(pod)
	sources := make(map[eventSource]bool)

for _, cstatus := range pod.Status.ContainerStatuses {
		if filter.Accept(cstatus) {
			source := eventSource{id, cstatus.Name, pod.Spec.NodeName}
			sources[source] = true
		}
	}

for _, cstatus := range pod.Status.InitContainerStatuses {
		if filter.Accept(cstatus) {
			source := eventSource{id, cstatus.Name, pod.Spec.NodeName}
			sources[source] = true
		}
	}

return id, sources
}

func SourcesForPod(
	filter ContainerFilter, pod *v1.Pod) (nsname.NSName, []EventSource) {

id, internal := sourcesForPod(filter, pod)
	sources := make([]EventSource, 0, len(internal))

for source, _ := range internal {
		sources = append(sources, source)
	}

sort.Slice(sources, func(a, b int) bool {
		na := sources[a].Namespace() + sources[a].Name()
		nb := sources[b].Namespace() + sources[b].Name()
		return na < nb
	})

return id, sources
}
0707010000001F000081A4000000000000000000000001654148A1000009ED000000000000000000000000000000000000001300000000kail-0.17.0/go.modmodule github.com/boz/kail

go 1.20

require (
	github.com/boz/go-lifecycle v0.1.1
	github.com/boz/go-logutil v0.1.0
	github.com/boz/kcache v0.5.0
	github.com/fatih/color v1.15.0
	github.com/rs/zerolog v1.31.0
	github.com/sirupsen/logrus v1.9.3
	github.com/stretchr/testify v1.8.4
	gopkg.in/alecthomas/kingpin.v2 v2.2.6
	k8s.io/api v0.28.3
	k8s.io/apimachinery v0.28.3
	k8s.io/client-go v0.28.3
)

require (
	github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc // indirect
	github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf // indirect
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/emicklei/go-restful/v3 v3.9.0 // indirect
	github.com/go-logr/logr v1.2.4 // indirect
	github.com/go-openapi/jsonpointer v0.19.6 // indirect
	github.com/go-openapi/jsonreference v0.20.2 // indirect
	github.com/go-openapi/swag v0.22.3 // indirect
	github.com/gogo/protobuf v1.3.2 // indirect
	github.com/golang/protobuf v1.5.3 // indirect
	github.com/google/gnostic-models v0.6.8 // indirect
	github.com/google/go-cmp v0.5.9 // indirect
	github.com/google/gofuzz v1.2.0 // indirect
	github.com/google/uuid v1.3.0 // indirect
	github.com/imdario/mergo v0.3.6 // indirect
	github.com/josharian/intern v1.0.0 // indirect
	github.com/json-iterator/go v1.1.12 // 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.19 // indirect
	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
	github.com/modern-go/reflect2 v1.0.2 // indirect
	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
	github.com/pkg/errors v0.9.1 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	golang.org/x/net v0.17.0 // indirect
	golang.org/x/oauth2 v0.8.0 // indirect
	golang.org/x/sys v0.13.0 // indirect
	golang.org/x/term v0.13.0 // indirect
	golang.org/x/text v0.13.0 // indirect
	golang.org/x/time v0.3.0 // indirect
	google.golang.org/appengine v1.6.7 // indirect
	google.golang.org/protobuf v1.30.0 // indirect
	gopkg.in/inf.v0 v0.9.1 // indirect
	gopkg.in/yaml.v2 v2.4.0 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
	k8s.io/klog/v2 v2.100.1 // indirect
	k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9 // indirect
	k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 // indirect
	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
	sigs.k8s.io/yaml v1.3.0 // indirect
)
07070100000020000081A4000000000000000000000001654148A100004243000000000000000000000000000000000000001300000000kail-0.17.0/go.sumgithub.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/boz/go-lifecycle v0.1.1 h1:tG/wff7Zxbkf19g4D4I0G8Y4sq83iT5QjD4rzEf/zrI=
github.com/boz/go-lifecycle v0.1.1/go.mod h1:zdagAUMcC2C0OmQkBlJZFV77uF4GCVaGphAexGi7oho=
github.com/boz/go-logutil v0.1.0 h1:v6gtJGq+dz2NSWb5IXosEnaJ8Uo/V9z4JQWyjvQJGgg=
github.com/boz/go-logutil v0.1.0/go.mod h1:CXkIsoVfGPwOxTaTaS+xry4ohurGiGuT3A84vSzX9BM=
github.com/boz/kcache v0.5.0 h1:AnDx0ZVtozlG/YB4FcrPXh7VPH5ZZUyV+M//V630LCM=
github.com/boz/kcache v0.5.0/go.mod h1:I/V40xLoVaBuVJppMwW50WV+LbfuM/NuY0qAD91ljsQ=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
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.9.0 h1:XwGDlfxEnQZzuopoqxwSEllNcCOM9DhhFyhFIIGKwxE=
github.com/emicklei/go-restful/v3 v3.9.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-openapi/jsonpointer v0.19.6 h1:eCs3fxoIi3Wh6vtgmLTOjdhSpiqphQ+DaPn38N2ZdrE=
github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs=
github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE=
github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k=
github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g=
github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
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.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
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/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 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/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/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28=
github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
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/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/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
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.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
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/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.9.4 h1:xR7vG4IXt5RWx6FfIjyAtsoMAtnc3C/rFXBBd2AjZwE=
github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
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.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
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.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
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.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
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/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
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/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
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.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8=
golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE=
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/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/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-20220715151400-c0bba94af5f8/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.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
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.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
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.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
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.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
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/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.28.3 h1:Gj1HtbSdB4P08C8rs9AR94MfSGpRhJgsS+GF9V26xMM=
k8s.io/api v0.28.3/go.mod h1:MRCV/jr1dW87/qJnZ57U5Pak65LGmQVkKTzf3AtKFHc=
k8s.io/apimachinery v0.28.3 h1:B1wYx8txOaCQG0HmYF6nbpU8dg6HvA06x5tEffvOe7A=
k8s.io/apimachinery v0.28.3/go.mod h1:uQTKmIqs+rAYaq+DFaoD2X7pcjLOqbQX2AOiO0nIpb8=
k8s.io/client-go v0.28.3 h1:2OqNb72ZuTZPKCl+4gTKvqao0AMOl9f3o2ijbAj3LI4=
k8s.io/client-go v0.28.3/go.mod h1:LTykbBp9gsA7SwqirlCXBWtK0guzfhpoW4qSm7i9dxo=
k8s.io/klog/v2 v2.100.1 h1:7WCHKK6K8fNhTqfBhISHQ97KrnJNFZMcQvKp7gP/tmg=
k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9 h1:LyMgNKD2P8Wn1iAwQU5OhxCKlKJy0sHc+PcDwFB24dQ=
k8s.io/kube-openapi v0.0.0-20230717233707-2695361300d9/go.mod h1:wZK2AVp1uHCp4VamDVgBP2COHZjqD1T68Rf0CM3YjSM=
k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 h1:qY1Ad8PODbnymg2pRbkyMT/ylpTrCM8P2RJ0yroCyIk=
k8s.io/utils v0.0.0-20230406110748-d93618cff8a2/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/structured-merge-diff/v4 v4.2.3 h1:PRbqxJClWWYMNV1dhaG4NsibJbArud9kFxnAMREiWFE=
sigs.k8s.io/structured-merge-diff/v4 v4.2.3/go.mod h1:qjx8mGObPmV2aSZepjQjbmb2ihdVs8cGKBraizNC69E=
sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo=
sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8=
07070100000021000081A4000000000000000000000001654148A100000F1E000000000000000000000000000000000000001700000000kail-0.17.0/monitor.gopackage kail

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

v1 "k8s.io/api/core/v1"
	"k8s.io/client-go/kubernetes"
	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
	"k8s.io/client-go/rest"

lifecycle "github.com/boz/go-lifecycle"
	logutil "github.com/boz/go-logutil"
)

const (
	logBufsiz          = 1024 * 16 // 16k max message size
	monitorDeliverWait = time.Millisecond
)

var (
	canaryLog = []byte("unexpected stream type \"\"")
)

type monitorConfig struct {
	since time.Duration
}

type monitor interface {
	Shutdown()
	Done() <-chan struct{}
}

func newMonitor(c *controller, source EventSource, config monitorConfig) monitor {
	lc := lifecycle.New()
	go lc.WatchContext(c.ctx)

log := c.log.WithComponent(
		fmt.Sprintf("monitor [%v]", source))

m := &_monitor{
		rc:      c.rc,
		source:  source,
		config:  config,
		eventch: c.eventch,
		log:     log,
		lc:      lc,
		ctx:     c.ctx,
	}

go m.run()

return m
}

type _monitor struct {
	rc      *rest.Config
	source  EventSource
	config  monitorConfig
	eventch chan<- Event
	log     logutil.Log
	lc      lifecycle.Lifecycle
	ctx     context.Context
}

func (m *_monitor) Shutdown() {
	m.lc.ShutdownAsync(nil)
}

func (m *_monitor) Done() <-chan struct{} {
	return m.lc.Done()
}

func (m *_monitor) run() {
	defer m.log.Un(m.log.Trace("run"))
	defer m.lc.ShutdownCompleted()

ctx, cancel := context.WithCancel(m.ctx)

client, err := m.makeClient(ctx)
	if err != nil {
		m.lc.ShutdownInitiated(err)
		cancel()
		return
	}

donech := make(chan struct{})

go m.mainloop(ctx, client, donech)

err = <-m.lc.ShutdownRequest()
	m.lc.ShutdownInitiated(err)
	cancel()

<-donech
}

func (m *_monitor) makeClient(ctx context.Context) (corev1.CoreV1Interface, error) {
	cs, err := kubernetes.NewForConfig(m.rc)
	if err != nil {
		return nil, err
	}
	return cs.CoreV1(), nil
}

func (m *_monitor) mainloop(
	ctx context.Context, client corev1.CoreV1Interface, donech chan struct{}) {
	defer m.log.Un(m.log.Trace("mainloop"))
	defer close(donech)

// todo: backoff handled by k8 client?

sinceSecs := int64(m.config.since / time.Second)
	since := &sinceSecs

m.log.Debugf("displaying logs since %v seconds", sinceSecs)

for i := 0; ctx.Err() == nil; i++ {

m.log.Debugf("readloop count: %v", i)

err := m.readloop(ctx, client, since)
		switch {
		case err == io.EOF:
		case err == nil:
		case ctx.Err() != nil:
			m.lc.ShutdownAsync(nil)
			return
		default:
			m.log.ErrWarn(err, "streaming done")
			m.lc.ShutdownAsync(err)
			return
		}
		sinceSecs = 1
	}
}

func (m *_monitor) readloop(
	ctx context.Context, client corev1.CoreV1Interface, since *int64) error {

defer m.log.Un(m.log.Trace("readloop"))

opts := &v1.PodLogOptions{
		Container:    m.source.Container(),
		Follow:       true,
		SinceSeconds: since,
	}

req := client.
		Pods(m.source.Namespace()).
		GetLogs(m.source.Name(), opts)

stream, err := req.Stream(ctx)
	if err != nil {
		return err
	}

defer stream.Close()

logbuf := make([]byte, logBufsiz)
	buffer := newBuffer(m.source)

for ctx.Err() == nil {
		nread, err := stream.Read(logbuf)

switch {
		case err == io.EOF:
			return err
		case ctx.Err() != nil:
			return ctx.Err()
		case err != nil:
			return m.log.Err(err, "error while reading logs")
		case nread == 0:
			return io.EOF
		}

log := logbuf[0:nread]

if bytes.Equal(canaryLog, log) {
			m.log.Debugf("received 'unexpect stream type'")
			continue
		}

if events := buffer.process(log); len(events) > 0 {
			m.deliverEvents(ctx, events)
		}

}
	return nil
}

func (m *_monitor) deliverEvents(ctx context.Context, events []Event) {
	t := time.NewTimer(monitorDeliverWait)
	defer t.Stop()

for i, event := range events {
		select {
		case m.eventch <- event:
		case <-t.C:
			m.log.Warnf("event buffer full. dropping %v logs", len(events)-i)
			return
		case <-ctx.Done():
			return
		}
	}
}
07070100000022000081A4000000000000000000000001654148A1000003AF000000000000000000000000000000000000001400000000kail-0.17.0/util.gopackage kail

import (
	"fmt"

"github.com/boz/kcache/nsname"
)

type EventSource interface {
	Namespace() string
	Name() string
	Container() string
	Node() string
}

type eventSource struct {
	id        nsname.NSName
	container string
	node      string
}

func (es eventSource) Namespace() string {
	return es.id.Namespace
}

func (es eventSource) Name() string {
	return es.id.Name
}

func (es eventSource) Container() string {
	return es.container
}

func (es eventSource) Node() string {
	return es.node
}

func (es eventSource) String() string {
	return fmt.Sprintf("%v/%v@%v",
		es.id.Namespace, es.id.Name, es.container)
}

type Event interface {
	Source() EventSource
	Log() []byte
}

func newEvent(source EventSource, log []byte) Event {
	return &event{source, log}
}

type event struct {
	source EventSource
	log    []byte
}

func (e *event) Source() EventSource {
	return e.source
}

func (e *event) Log() []byte {
	return e.log
}
07070100000023000041ED000000000000000000000002654148A100000000000000000000000000000000000000000000001400000000kail-0.17.0/writers07070100000024000081A4000000000000000000000001654148A1000002B0000000000000000000000000000000000000001F00000000kail-0.17.0/writers/default.gopackage writers

import (
	"fmt"
	"io"

"github.com/boz/kail"
)

func NewWriter(out io.Writer) Writer {
	return &writer{writerRaw{out}}
}

type writer struct {
	writerRaw
}

func (w *writer) Print(ev kail.Event) error {
	return w.Fprint(w.out, ev)
}

func (w *writer) Fprint(out io.Writer, ev kail.Event) error {
	prefix := w.prefix(ev)

if _, err := prefixColor.Fprint(out, prefix); err != nil {
		return err
	}
	if _, err := prefixColor.Fprint(out, ": "); err != nil {
		return err
	}

return w.writerRaw.Fprint(out, ev)
}

func (w *writer) prefix(ev kail.Event) string {
	return fmt.Sprintf("%v/%v[%v]",
		ev.Source().Namespace(),
		ev.Source().Name(),
		ev.Source().Container())
}
07070100000025000081A4000000000000000000000001654148A1000004A4000000000000000000000000000000000000001C00000000kail-0.17.0/writers/json.gopackage writers

import (
	"encoding/json"
	"io"

"github.com/boz/kail"
)

func NewJSONWriter(out io.Writer) Writer {
	return &writerJSON{
		out: out,
		getEnc: func(o io.Writer) *json.Encoder {
			return json.NewEncoder(o)
		},
	}
}

func NewJSONPrettyWriter(out io.Writer) Writer {
	return &writerJSON{
		out: out,
		getEnc: func(o io.Writer) *json.Encoder {
			e := json.NewEncoder(o)
			e.SetIndent("", "  ")
			return e
		},
	}
}

type writerJSON struct {
	out    io.Writer
	getEnc func(io.Writer) *json.Encoder
}

func (w *writerJSON) Print(ev kail.Event) error {
	return w.Fprint(w.out, ev)
}

func (w *writerJSON) Fprint(out io.Writer, ev kail.Event) error {

log := ev.Log()
	if sz := len(log); sz == 0 || log[sz-1] == byte('\n') {
		log = log[:sz-1]
	}

enc := w.getEnc(out)

data := map[string]interface{}{
		"namespace": ev.Source().Namespace(),
		"name":      ev.Source().Name(),
		"container": ev.Source().Container(),
	}

messageMap := map[string]interface{}{}
	if err := json.Unmarshal(log, &messageMap); err != nil {
		data["message"] = string(log)
	} else {
		data["message"] = messageMap
	}

if err := enc.Encode(data); err != nil {
		return err
	}
	return nil
}
07070100000026000081A4000000000000000000000001654148A10000021A000000000000000000000000000000000000001B00000000kail-0.17.0/writers/raw.gopackage writers

import (
	"io"

"github.com/boz/kail"
)

func NewRawWriter(out io.Writer) Writer {
	return &writerRaw{out}
}

type writerRaw struct {
	out io.Writer
}

func (w *writerRaw) Print(ev kail.Event) error {
	return w.Fprint(w.out, ev)
}

func (w *writerRaw) Fprint(out io.Writer, ev kail.Event) error {
	log := ev.Log()

if _, err := out.Write(log); err != nil {
		return err
	}

if sz := len(log); sz == 0 || log[sz-1] != byte('\n') {
		if _, err := out.Write([]byte("\n")); err != nil {
			return err
		}
	}
	return nil
}
07070100000027000081A4000000000000000000000001654148A1000000FA000000000000000000000000000000000000001E00000000kail-0.17.0/writers/writer.gopackage writers

import (
	"io"

"github.com/boz/kail"
	"github.com/fatih/color"
)

var (
	prefixColor = color.New(color.FgHiWhite, color.Bold)
)

type Writer interface {
	Print(event kail.Event) error
	Fprint(w io.Writer, event kail.Event) error
}
07070100000028000081A4000000000000000000000001654148A1000004E6000000000000000000000000000000000000001F00000000kail-0.17.0/writers/zerolog.gopackage writers

import (
	"encoding/json"
	"fmt"
	"io"

"github.com/boz/kail"
	"github.com/rs/zerolog"
)

func NewZerologWriter(out io.Writer) Writer {
	return &zerologwriter{out}
}

type zerologwriter struct {
	out io.Writer
}

func (w *zerologwriter) Print(ev kail.Event) error {
	return w.Fprint(w.out, ev)
}

func (w *zerologwriter) Fprint(out io.Writer, ev kail.Event) error {
	prefix := w.prefix(ev)

if _, err := prefixColor.Fprint(out, prefix); err != nil {
		return err
	}
	if _, err := prefixColor.Fprint(out, ": "); err != nil {
		return err
	}

log := ev.Log()

// Attempt to parse log as json
	var v interface{}
	if err := json.Unmarshal(log, &v); err == nil {
		consoleWriter := zerolog.ConsoleWriter{Out: w.out}
		if _, err := consoleWriter.Write(log); err != nil {
			return err
		}
		return nil
	}

// Could not parse as json, so revert to default log output
	if _, err := out.Write(log); err != nil {
		return err
	}

if sz := len(log); sz == 0 || log[sz-1] != byte('\n') {
		if _, err := out.Write([]byte("\n")); err != nil {
			return err
		}
	}
	return nil
}

func (w *zerologwriter) prefix(ev kail.Event) string {
	return fmt.Sprintf("%v/%v[%v]",
		ev.Source().Namespace(),
		ev.Source().Name(),
		ev.Source().Container())
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!174 blocks

Places

File kail-0.17.0.obscpio of Package kail (Revision 8dee1dba4e9a0350ec7952725eb1a357)

Places