github/kubeshark
1
0
Fork 0
mirror of https://github.com/kubeshark/kubeshark.git synced 2025-04-27 19:47:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

🔨 Move cli folder contents into project root (#1253)

Browse Source 
* Remove `logger` module

* Remove `shared` module

* Move `cli` folder contents into project root

* Fix linter

* Change the module name from `github.com/kubeshark/kubeshark/cli` to `github.com/kubeshark/kubeshark`

* Set the default `Makefile` rule to `build`

* Add `lint` rule

* Fix the linter errors
This commit is contained in:
M. Mert Yildiran 2022-11-25 14:17:50 -08:00 committed by GitHub
parent 9aeb1fadea
commit cb60a4cc4c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
92 changed files with 512 additions and 2219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.github/workflows/linter.yml vendored
View File

@ -24,22 +24,8 @@ jobs:
with:
go-version: '^1.17'
- name: Go lint - shared
- name: Go lint
uses: golangci/golangci-lint-action@v2
with:
version: latest
working-directory: shared
args: --timeout=10m
- name: Go lint - CLI
uses: golangci/golangci-lint-action@v2
with:
version: latest
working-directory: cli
args: --timeout=10m
- name: Go lint - logger
uses: golangci/golangci-lint-action@v2
with:
version: latest
working-directory: logger

2
.gitignore vendored
View File

@ -56,4 +56,4 @@ cypress.env.json
# Object files
*.o
hub
bin

72
Makefile
View File

@ -1,40 +1,58 @@
C_Y=\033[1;33m
C_C=\033[0;36m
C_M=\033[0;35m
C_R=\033[0;41m
C_N=\033[0m
SHELL=/bin/bash
# HELP
# This will output the help for each task
# thanks to https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
.PHONY: help cli
.PHONY: help
.DEFAULT_GOAL := build
.ONESHELL:
SUFFIX=$(GOOS)_$(GOARCH)
COMMIT_HASH=$(shell git rev-parse HEAD)
GIT_BRANCH=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
GIT_VERSION=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
BUILD_TIMESTAMP=$(shell date +%s)
export VER?=0.0
help: ## This help.
@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
.DEFAULT_GOAL := help
install:
go install kubeshark.go
cli: ## Build CLI.
@echo "building cli"; cd cli && $(MAKE) build
build-debug: ## Build kubeshark CLI for debug
export GCLFAGS='-gcflags="all=-N -l"'
${MAKE} build-base
cli-debug: ## Build CLI.
@echo "building cli"; cd cli && $(MAKE) build-debug
build:
export LDFLAGS_EXT='-s -w'
${MAKE} build-base
clean: clean-ui clean-cli ## Clean all build artifacts.
build-base: ## Build kubeshark CLI binary (select platform via GOOS / GOARCH env variables).
go build ${GCLFAGS} -ldflags="${LDFLAGS_EXT} \
-X 'github.com/kubeshark/kubeshark/kubeshark.GitCommitHash=$(COMMIT_HASH)' \
-X 'github.com/kubeshark/kubeshark/kubeshark.Branch=$(GIT_BRANCH)' \
-X 'github.com/kubeshark/kubeshark/kubeshark.BuildTimestamp=$(BUILD_TIMESTAMP)' \
-X 'github.com/kubeshark/kubeshark/kubeshark.Platform=$(SUFFIX)' \
-X 'github.com/kubeshark/kubeshark/kubeshark.Ver=$(VER)'" \
-o bin/kubeshark_$(SUFFIX) kubeshark.go
(cd bin && shasum -a 256 kubeshark_${SUFFIX} > kubeshark_${SUFFIX}.sha256)
clean-cli: ## Clean CLI.
@(cd cli; make clean ; echo "CLI cleanup done" )
build-all: ## Build for all supported platforms.
echo "Compiling for every OS and Platform" && \
mkdir -p bin && sed s/_VER_/$(VER)/g README.md.TEMPLATE > bin/README.md && \
$(MAKE) build GOOS=linux GOARCH=amd64 && \
$(MAKE) build GOOS=linux GOARCH=arm64 && \
$(MAKE) build GOOS=darwin GOARCH=amd64 && \
$(MAKE) build GOOS=darwin GOARCH=arm64 && \
$(MAKE) build GOOS=windows GOARCH=amd64 && \
mv ./bin/kubeshark_windows_amd64 ./bin/kubeshark.exe && \
echo "---------" && \
find ./bin -ls
clean: ## Clean all build artifacts.
go clean
rm -rf ./bin/*
lint: ## Run lint on all modules
cd shared && golangci-lint run
cd cli && golangci-lint run
test: ## Run cli tests.
@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic
test: test-cli test-shared
test-cli: ## Run cli tests
@echo "running cli tests"; cd cli && $(MAKE) test
test-shared: ## Run shared tests
@echo "running shared tests"; cd shared && $(MAKE) test
lint: ## Run linter
golangci-lint run

0
cli/README.md.TEMPLATE → README.md.TEMPLATE
View File

18
cli/apiserver/provider.go → apiserver/provider.go
View File

@ -4,14 +4,14 @@ import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
"time"
"github.com/kubeshark/kubeshark/cli/utils"
"github.com/kubeshark/kubeshark/utils"
"github.com/kubeshark/worker/models"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/config"
core "k8s.io/api/core/v1"
)
@ -38,9 +38,9 @@ func (provider *Provider) TestConnection(path string) error {
retriesLeft := provider.retries
for retriesLeft > 0 {
if isReachable, err := provider.isReachable(path); err != nil || !isReachable {
logger.Log.Debugf("api server not ready yet %v", err)
log.Printf("api server not ready yet %v", err)
} else {
logger.Log.Debugf("connection test to api server passed successfully")
log.Printf("connection test to api server passed successfully")
break
}
retriesLeft -= 1
@ -62,7 +62,7 @@ func (provider *Provider) isReachable(path string) (bool, error) {
}
}
func (provider *Provider) ReportTapperStatus(tapperStatus shared.TapperStatus) error {
func (provider *Provider) ReportTapperStatus(tapperStatus models.TapperStatus) error {
tapperStatusUrl := fmt.Sprintf("%s/status/tapperStatus", provider.url)
if jsonValue, err := json.Marshal(tapperStatus); err != nil {
@ -71,7 +71,7 @@ func (provider *Provider) ReportTapperStatus(tapperStatus shared.TapperStatus) e
if _, err := utils.Post(tapperStatusUrl, "application/json", bytes.NewBuffer(jsonValue), provider.client); err != nil {
return fmt.Errorf("failed sending to API server the tapped pods %w", err)
} else {
logger.Log.Debugf("Reported to server API about tapper status: %v", tapperStatus)
log.Printf("Reported to server API about tapper status: %v", tapperStatus)
return nil
}
}
@ -86,7 +86,7 @@ func (provider *Provider) ReportTappedPods(pods []core.Pod) error {
if _, err := utils.Post(tappedPodsUrl, "application/json", bytes.NewBuffer(jsonValue), provider.client); err != nil {
return fmt.Errorf("failed sending to API server the tapped pods %w", err)
} else {
logger.Log.Debugf("Reported to server API about %d taped pods successfully", len(pods))
log.Printf("Reported to server API about %d taped pods successfully", len(pods))
return nil
}
}

2
cli/bucket/provider.go → bucket/provider.go
View File

@ -6,7 +6,7 @@ import (
"net/http"
"time"
"github.com/kubeshark/kubeshark/cli/utils"
"github.com/kubeshark/kubeshark/utils"
)
type Provider struct {

1
cli/.gitignore vendored
View File

@ -1 +0,0 @@
bin

55
cli/Makefile
View File

@ -1,55 +0,0 @@
SHELL=/bin/bash
.PHONY: help
.DEFAULT_GOAL := help
.ONESHELL:
SUFFIX=$(GOOS)_$(GOARCH)
COMMIT_HASH=$(shell git rev-parse HEAD)
GIT_BRANCH=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
GIT_VERSION=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
BUILD_TIMESTAMP=$(shell date +%s)
export VER?=0.0
help: ## This help.
@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
install:
go install kubeshark.go
build-debug: ## Build kubeshark CLI for debug
export GCLFAGS='-gcflags="all=-N -l"'
${MAKE} build-base
build:
export LDFLAGS_EXT='-s -w'
${MAKE} build-base
build-base: ## Build kubeshark CLI binary (select platform via GOOS / GOARCH env variables).
go build ${GCLFAGS} -ldflags="${LDFLAGS_EXT} \
-X 'github.com/kubeshark/kubeshark/cli/kubeshark.GitCommitHash=$(COMMIT_HASH)' \
-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Branch=$(GIT_BRANCH)' \
-X 'github.com/kubeshark/kubeshark/cli/kubeshark.BuildTimestamp=$(BUILD_TIMESTAMP)' \
-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Platform=$(SUFFIX)' \
-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Ver=$(VER)'" \
-o bin/kubeshark_$(SUFFIX) kubeshark.go
(cd bin && shasum -a 256 kubeshark_${SUFFIX} > kubeshark_${SUFFIX}.sha256)
build-all: ## Build for all supported platforms.
echo "Compiling for every OS and Platform" && \
mkdir -p bin && sed s/_VER_/$(VER)/g README.md.TEMPLATE > bin/README.md && \
$(MAKE) build GOOS=linux GOARCH=amd64 && \
$(MAKE) build GOOS=linux GOARCH=arm64 && \
$(MAKE) build GOOS=darwin GOARCH=amd64 && \
$(MAKE) build GOOS=darwin GOARCH=arm64 && \
$(MAKE) build GOOS=windows GOARCH=amd64 && \
mv ./bin/kubeshark_windows_amd64 ./bin/kubeshark.exe && \
echo "---------" && \
find ./bin -ls
clean: ## Clean all build artifacts.
go clean
rm -rf ./bin/*
test: ## Run cli tests.
@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

31
cli/cmd/check/kubernetesApi.go
View File

@ -1,31 +0,0 @@
package check
import (
"fmt"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/shared/semver"
)
func KubernetesApi() (*kubernetes.Provider, *semver.SemVersion, bool) {
logger.Log.Infof("\nkubernetes-api\n--------------------")
kubernetesProvider, err := kubernetes.NewProvider(config.Config.KubeConfigPath(), config.Config.KubeContext)
if err != nil {
logger.Log.Errorf("%v can't initialize the client, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return nil, nil, false
}
logger.Log.Infof("%v can initialize the client", fmt.Sprintf(uiUtils.Green, "√"))
kubernetesVersion, err := kubernetesProvider.GetKubernetesVersion()
if err != nil {
logger.Log.Errorf("%v can't query the Kubernetes API, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return nil, nil, false
}
logger.Log.Infof("%v can query the Kubernetes API", fmt.Sprintf(uiUtils.Green, "√"))
return kubernetesProvider, kubernetesVersion, true
}

22
cli/cmd/check/kubernetesVersion.go
View File

@ -1,22 +0,0 @@
package check
import (
"fmt"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/shared/semver"
)
func KubernetesVersion(kubernetesVersion *semver.SemVersion) bool {
logger.Log.Infof("\nkubernetes-version\n--------------------")
if err := kubernetes.ValidateKubernetesVersion(kubernetesVersion); err != nil {
logger.Log.Errorf("%v not running the minimum Kubernetes API version, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
logger.Log.Infof("%v is running the minimum Kubernetes API version", fmt.Sprintf(uiUtils.Green, "√"))
return true
}

10
cli/kubeshark.go
View File

@ -1,10 +0,0 @@
package main
import (
"github.com/kubeshark/kubeshark/cli/cmd"
"github.com/kubeshark/kubeshark/cli/cmd/goUtils"
)
func main() {
goUtils.HandleExcWrapper(cmd.Execute)
}

7
cli/cmd/check.go → cmd/check.go
View File

@ -1,9 +1,10 @@
package cmd
import (
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/spf13/cobra"
)
@ -21,7 +22,7 @@ func init() {
defaultCheckConfig := configStructs.CheckConfig{}
if err := defaults.Set(&defaultCheckConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
checkCmd.Flags().Bool(configStructs.PreTapCheckName, defaultCheckConfig.PreTap, "Check pre-tap Kubeshark installation for potential problems")

16
cli/cmd/check/imagePullInCluster.go → cmd/check/imagePullInCluster.go
View File

@ -3,39 +3,39 @@ package check
import (
"context"
"fmt"
"log"
"regexp"
"time"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
core "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func ImagePullInCluster(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
logger.Log.Infof("\nimage-pull-in-cluster\n--------------------")
log.Printf("\nimage-pull-in-cluster\n--------------------")
namespace := "default"
podName := "kubeshark-test"
defer func() {
if err := kubernetesProvider.RemovePod(ctx, namespace, podName); err != nil {
logger.Log.Errorf("%v error while removing test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while removing test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
}
}()
if err := createImagePullInClusterPod(ctx, kubernetesProvider, namespace, podName); err != nil {
logger.Log.Errorf("%v error while creating test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while creating test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
if err := checkImagePulled(ctx, kubernetesProvider, namespace, podName); err != nil {
logger.Log.Errorf("%v cluster is not able to pull kubeshark containers from docker hub, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v cluster is not able to pull kubeshark containers from docker hub, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
logger.Log.Infof("%v cluster is able to pull kubeshark containers from docker hub", fmt.Sprintf(uiUtils.Green, "√"))
log.Printf("%v cluster is able to pull kubeshark containers from docker hub", fmt.Sprintf(uiUtils.Green, "√"))
return true
}

31
cmd/check/kubernetesApi.go Normal file
View File

@ -0,0 +1,31 @@
package check
import (
"fmt"
"log"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/semver"
"github.com/kubeshark/kubeshark/uiUtils"
)
func KubernetesApi() (*kubernetes.Provider, *semver.SemVersion, bool) {
log.Printf("\nkubernetes-api\n--------------------")
kubernetesProvider, err := kubernetes.NewProvider(config.Config.KubeConfigPath(), config.Config.KubeContext)
if err != nil {
log.Printf("%v can't initialize the client, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return nil, nil, false
}
log.Printf("%v can initialize the client", fmt.Sprintf(uiUtils.Green, "√"))
kubernetesVersion, err := kubernetesProvider.GetKubernetesVersion()
if err != nil {
log.Printf("%v can't query the Kubernetes API, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return nil, nil, false
}
log.Printf("%v can query the Kubernetes API", fmt.Sprintf(uiUtils.Green, "√"))
return kubernetesProvider, kubernetesVersion, true
}

30
cli/cmd/check/kubernetesPermissions.go → cmd/check/kubernetesPermissions.go
View File

@ -4,20 +4,20 @@ import (
"context"
"embed"
"fmt"
"log"
"strings"
"github.com/kubeshark/kubeshark/cli/bucket"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/bucket"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
rbac "k8s.io/api/rbac/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes/scheme"
)
func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesProvider *kubernetes.Provider) bool {
logger.Log.Infof("\nkubernetes-permissions\n--------------------")
log.Printf("\nkubernetes-permissions\n--------------------")
var filePath string
if config.Config.IsNsRestrictedMode() {
@ -28,14 +28,14 @@ func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesP
data, err := embedFS.ReadFile(filePath)
if err != nil {
logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode(data, nil, nil)
if err != nil {
logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
@ -46,17 +46,17 @@ func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesP
return checkRulesPermissions(ctx, kubernetesProvider, resource.Rules, "")
}
logger.Log.Errorf("%v error while checking kubernetes permissions, err: resource of type 'Role' or 'ClusterRole' not found in permission files", fmt.Sprintf(uiUtils.Red, "✗"))
log.Printf("%v error while checking kubernetes permissions, err: resource of type 'Role' or 'ClusterRole' not found in permission files", fmt.Sprintf(uiUtils.Red, "✗"))
return false
}
func InstallKubernetesPermissions(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
logger.Log.Infof("\nkubernetes-permissions\n--------------------")
log.Printf("\nkubernetes-permissions\n--------------------")
bucketProvider := bucket.NewProvider(config.Config.Install.TemplateUrl, bucket.DefaultTimeout)
installTemplate, err := bucketProvider.GetInstallTemplate(config.Config.Install.TemplateName)
if err != nil {
logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
@ -68,7 +68,7 @@ func InstallKubernetesPermissions(ctx context.Context, kubernetesProvider *kuber
for _, resourceTemplate := range resourcesTemplate {
obj, _, err := decode([]byte(resourceTemplate), nil, nil)
if err != nil {
logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
@ -120,13 +120,13 @@ func checkPermissionExist(group string, resource string, verb string, namespace
}
if err != nil {
logger.Log.Errorf("%v error checking permission for %v %v %v, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace, err)
log.Printf("%v error checking permission for %v %v %v, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace, err)
return false
} else if !exist {
logger.Log.Errorf("%v can't %v %v %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace)
log.Printf("%v can't %v %v %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace)
return false
}
logger.Log.Infof("%v can %v %v %v", fmt.Sprintf(uiUtils.Green, "√"), verb, resource, groupAndNamespace)
log.Printf("%v can %v %v %v", fmt.Sprintf(uiUtils.Green, "√"), verb, resource, groupAndNamespace)
return true
}

30
cli/cmd/check/kubernetesResources.go → cmd/check/kubernetesResources.go
View File

@ -3,15 +3,15 @@ package check
import (
"context"
"fmt"
"log"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
)
func KubernetesResources(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
logger.Log.Infof("\nk8s-components\n--------------------")
log.Printf("\nk8s-components\n--------------------")
exist, err := kubernetesProvider.DoesNamespaceExist(ctx, config.Config.KubesharkResourcesNamespace)
allResourcesExist := checkResourceExist(config.Config.KubesharkResourcesNamespace, "namespace", exist, err)
@ -46,20 +46,20 @@ func KubernetesResources(ctx context.Context, kubernetesProvider *kubernetes.Pro
func checkPodResourcesExist(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
if pods, err := kubernetesProvider.ListPodsByAppLabel(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.ApiServerPodName); err != nil {
logger.Log.Errorf("%v error checking if '%v' pod is running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName, err)
log.Printf("%v error checking if '%v' pod is running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName, err)
return false
} else if len(pods) == 0 {
logger.Log.Errorf("%v '%v' pod doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
log.Printf("%v '%v' pod doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
return false
} else if !kubernetes.IsPodRunning(&pods[0]) {
logger.Log.Errorf("%v '%v' pod not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
log.Printf("%v '%v' pod not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
return false
}
logger.Log.Infof("%v '%v' pod running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.ApiServerPodName)
log.Printf("%v '%v' pod running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.ApiServerPodName)
if pods, err := kubernetesProvider.ListPodsByAppLabel(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.TapperPodName); err != nil {
logger.Log.Errorf("%v error checking if '%v' pods are running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, err)
log.Printf("%v error checking if '%v' pods are running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, err)
return false
} else {
tappers := 0
@ -73,24 +73,24 @@ func checkPodResourcesExist(ctx context.Context, kubernetesProvider *kubernetes.
}
if notRunningTappers > 0 {
logger.Log.Errorf("%v '%v' %v/%v pods are not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, notRunningTappers, tappers)
log.Printf("%v '%v' %v/%v pods are not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, notRunningTappers, tappers)
return false
}
logger.Log.Infof("%v '%v' %v pods running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.TapperPodName, tappers)
log.Printf("%v '%v' %v pods running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.TapperPodName, tappers)
return true
}
}
func checkResourceExist(resourceName string, resourceType string, exist bool, err error) bool {
if err != nil {
logger.Log.Errorf("%v error checking if '%v' %v exists, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType, err)
log.Printf("%v error checking if '%v' %v exists, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType, err)
return false
} else if !exist {
logger.Log.Errorf("%v '%v' %v doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType)
log.Printf("%v '%v' %v doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType)
return false
}
logger.Log.Infof("%v '%v' %v exists", fmt.Sprintf(uiUtils.Green, "√"), resourceName, resourceType)
log.Printf("%v '%v' %v exists", fmt.Sprintf(uiUtils.Green, "√"), resourceName, resourceType)
return true
}

22
cmd/check/kubernetesVersion.go Normal file
View File

@ -0,0 +1,22 @@
package check
import (
"fmt"
"log"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/semver"
"github.com/kubeshark/kubeshark/uiUtils"
)
func KubernetesVersion(kubernetesVersion *semver.SemVersion) bool {
log.Printf("\nkubernetes-version\n--------------------")
if err := kubernetes.ValidateKubernetesVersion(kubernetesVersion); err != nil {
log.Printf("%v not running the minimum Kubernetes API version, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
return false
}
log.Printf("%v is running the minimum Kubernetes API version", fmt.Sprintf(uiUtils.Green, "√"))
return true
}

24
cli/cmd/check/serverConnection.go → cmd/check/serverConnection.go
View File

@ -3,40 +3,40 @@ package check
import (
"context"
"fmt"
"log"
"regexp"
"github.com/kubeshark/kubeshark/cli/apiserver"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/apiserver"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
)
func ServerConnection(kubernetesProvider *kubernetes.Provider) bool {
logger.Log.Infof("\nAPI-server-connectivity\n--------------------")
log.Printf("\nAPI-server-connectivity\n--------------------")
serverUrl := kubernetes.GetLocalhostOnPort(config.Config.Hub.PortForward.SrcPort)
apiServerProvider := apiserver.NewProvider(serverUrl, 1, apiserver.DefaultTimeout)
if err := apiServerProvider.TestConnection(""); err == nil {
logger.Log.Infof("%v found Kubeshark server tunnel available and connected successfully to API server", fmt.Sprintf(uiUtils.Green, "√"))
log.Printf("%v found Kubeshark server tunnel available and connected successfully to API server", fmt.Sprintf(uiUtils.Green, "√"))
return true
}
connectedToApiServer := false
if err := checkProxy(serverUrl, kubernetesProvider); err != nil {
logger.Log.Errorf("%v couldn't connect to API server using proxy, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v couldn't connect to API server using proxy, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
} else {
connectedToApiServer = true
logger.Log.Infof("%v connected successfully to API server using proxy", fmt.Sprintf(uiUtils.Green, "√"))
log.Printf("%v connected successfully to API server using proxy", fmt.Sprintf(uiUtils.Green, "√"))
}
if err := checkPortForward(serverUrl, kubernetesProvider); err != nil {
logger.Log.Errorf("%v couldn't connect to API server using port-forward, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
log.Printf("%v couldn't connect to API server using port-forward, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
} else {
connectedToApiServer = true
logger.Log.Infof("%v connected successfully to API server using port-forward", fmt.Sprintf(uiUtils.Green, "√"))
log.Printf("%v connected successfully to API server using port-forward", fmt.Sprintf(uiUtils.Green, "√"))
}
return connectedToApiServer
@ -57,7 +57,7 @@ func checkProxy(serverUrl string, kubernetesProvider *kubernetes.Provider) error
}
if err := httpServer.Shutdown(ctx); err != nil {
logger.Log.Debugf("Error occurred while stopping proxy, err: %v", err)
log.Printf("Error occurred while stopping proxy, err: %v", err)
}
return nil

14
cli/cmd/checkRunner.go → cmd/checkRunner.go
View File

@ -4,11 +4,11 @@ import (
"context"
"embed"
"fmt"
"log"
"github.com/kubeshark/kubeshark/cli/cmd/check"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/cmd/check"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/uiUtils"
)
var (
@ -17,7 +17,7 @@ var (
)
func runKubesharkCheck() {
logger.Log.Infof("Kubeshark checks\n===================")
log.Printf("Kubeshark checks\n===================")
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // cancel will be called when this function exits
@ -55,8 +55,8 @@ func runKubesharkCheck() {
}
if checkPassed {
logger.Log.Infof("\nStatus check results are %v", fmt.Sprintf(uiUtils.Green, "√"))
log.Printf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Green, "√"))
} else {
logger.Log.Errorf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Red, "✗"))
log.Printf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Red, "✗"))
}
}

0
cli/cmd/clean.go → cmd/clean.go
View File

2
cli/cmd/cleanRunner.go → cmd/cleanRunner.go
View File

@ -1,7 +1,7 @@
package cmd
import (
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/config"
)
func performCleanCommand() {

40
cli/cmd/common.go → cmd/common.go
View File

@ -5,28 +5,28 @@ import (
"encoding/json"
"errors"
"fmt"
"log"
"path"
"regexp"
"time"
"github.com/kubeshark/kubeshark/cli/apiserver"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/cli/resources"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/apiserver"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/kubeshark/kubeshark/kubeshark"
"github.com/kubeshark/kubeshark/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/resources"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/worker/models"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
)
func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx context.Context, cancel context.CancelFunc, serviceName string, srcPort uint16, dstPort uint16, healthCheck string) {
httpServer, err := kubernetes.StartProxy(kubernetesProvider, config.Config.Tap.ProxyHost, srcPort, dstPort, config.Config.KubesharkResourcesNamespace, serviceName, cancel)
if err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error occured while running k8s proxy %v\n"+
log.Printf(uiUtils.Error, fmt.Sprintf("Error occured while running k8s proxy %v\n"+
"Try setting different port by using --%s", errormessage.FormatError(err), configStructs.GuiPortTapName))
cancel()
return
@ -34,14 +34,14 @@ func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx con
provider := apiserver.NewProvider(kubernetes.GetLocalhostOnPort(srcPort), apiserver.DefaultRetries, apiserver.DefaultTimeout)
if err := provider.TestConnection(healthCheck); err != nil {
logger.Log.Debugf("Couldn't connect using proxy, stopping proxy and trying to create port-forward")
log.Printf("Couldn't connect using proxy, stopping proxy and trying to create port-forward")
if err := httpServer.Shutdown(ctx); err != nil {
logger.Log.Debugf("Error occurred while stopping proxy %v", errormessage.FormatError(err))
log.Printf("Error occurred while stopping proxy %v", errormessage.FormatError(err))
}
podRegex, _ := regexp.Compile(kubernetes.ApiServerPodName)
if _, err := kubernetes.NewPortForward(kubernetesProvider, config.Config.KubesharkResourcesNamespace, podRegex, srcPort, dstPort, ctx, cancel); err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error occured while running port forward [%s] %v\n"+
log.Printf(uiUtils.Error, fmt.Sprintf("Error occured while running port forward [%s] %v\n"+
"Try setting different port by using --%s", podRegex, errormessage.FormatError(err), configStructs.GuiPortTapName))
cancel()
return
@ -49,7 +49,7 @@ func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx con
provider = apiserver.NewProvider(kubernetes.GetLocalhostOnPort(srcPort), apiserver.DefaultRetries, apiserver.DefaultTimeout)
if err := provider.TestConnection(healthCheck); err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Couldn't connect to [%s], for more info check logs at %s", serviceName, fsUtils.GetLogFilePath()))
log.Printf(uiUtils.Error, "Couldn't connect to [%s].")
// cancel()
return
}
@ -85,9 +85,9 @@ func getKubernetesProviderForCli() (*kubernetes.Provider, error) {
func handleKubernetesProviderError(err error) {
var clusterBehindProxyErr *kubernetes.ClusterBehindProxyError
if ok := errors.As(err, &clusterBehindProxyErr); ok {
logger.Log.Errorf("cannot establish http-proxy connection to the Kubernetes cluster. If you’re using Lens or similar tool, please run kubeshark with regular kubectl config using --%v %v=$HOME/.kube/config flag", config.SetCommandName, config.KubeConfigPathConfigName)
log.Printf("cannot establish http-proxy connection to the Kubernetes cluster. If you’re using Lens or similar tool, please run kubeshark with regular kubectl config using --%v %v=$HOME/.kube/config flag", config.SetCommandName, config.KubeConfigPathConfigName)
} else {
logger.Log.Error(err)
log.Print(err)
}
}
@ -105,11 +105,11 @@ func dumpLogsIfNeeded(ctx context.Context, kubernetesProvider *kubernetes.Provid
kubesharkDir := kubeshark.GetKubesharkFolderPath()
filePath := path.Join(kubesharkDir, fmt.Sprintf("kubeshark_logs_%s.zip", time.Now().Format("2006_01_02__15_04_05")))
if err := fsUtils.DumpLogs(ctx, kubernetesProvider, filePath); err != nil {
logger.Log.Errorf("Failed dump logs %v", err)
log.Printf("Failed dump logs %v", err)
}
}
func getSerializedKubesharkAgentConfig(kubesharkAgentConfig *shared.KubesharkAgentConfig) (string, error) {
func getSerializedKubesharkAgentConfig(kubesharkAgentConfig *models.Config) (string, error) {
serializedConfig, err := json.Marshal(kubesharkAgentConfig)
if err != nil {
return "", err

20
cli/cmd/config.go → cmd/config.go
View File

@ -2,12 +2,12 @@ package cmd
import (
"fmt"
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/spf13/cobra"
)
@ -17,25 +17,25 @@ var configCmd = &cobra.Command{
RunE: func(cmd *cobra.Command, args []string) error {
configWithDefaults, err := config.GetConfigWithDefaults()
if err != nil {
logger.Log.Errorf("Failed generating config with defaults, err: %v", err)
log.Printf("Failed generating config with defaults, err: %v", err)
return nil
}
if config.Config.Config.Regenerate {
if err := config.WriteConfig(configWithDefaults); err != nil {
logger.Log.Errorf("Failed writing config with defaults, err: %v", err)
log.Printf("Failed writing config with defaults, err: %v", err)
return nil
}
logger.Log.Infof(fmt.Sprintf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, config.Config.ConfigFilePath)))
log.Printf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, config.Config.ConfigFilePath))
} else {
template, err := uiUtils.PrettyYaml(configWithDefaults)
if err != nil {
logger.Log.Errorf("Failed converting config with defaults to yaml, err: %v", err)
log.Printf("Failed converting config with defaults to yaml, err: %v", err)
return nil
}
logger.Log.Debugf("Writing template config.\n%v", template)
log.Printf("Writing template config.\n%v", template)
fmt.Printf("%v", template)
}
@ -48,7 +48,7 @@ func init() {
defaultConfig := config.CreateDefaultConfig()
if err := defaults.Set(&defaultConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
configCmd.Flags().BoolP(configStructs.RegenerateConfigName, "r", defaultConfig.Config.Regenerate, fmt.Sprintf("Regenerate the config file with default values to path %s or to chosen path using --%s", defaultConfig.ConfigFilePath, config.ConfigFilePathCommandName))

5
cli/cmd/goUtils/funcWrappers.go → cmd/goUtils/funcWrappers.go
View File

@ -1,17 +1,16 @@
package goUtils
import (
"log"
"reflect"
"runtime/debug"
"github.com/kubeshark/kubeshark/logger"
)
func HandleExcWrapper(fn interface{}, params ...interface{}) (result []reflect.Value) {
defer func() {
if panicMessage := recover(); panicMessage != nil {
stack := debug.Stack()
logger.Log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack)
log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack)
}
}()
f := reflect.ValueOf(fn)

7
cli/cmd/install.go → cmd/install.go
View File

@ -1,9 +1,10 @@
package cmd
import (
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/spf13/cobra"
)
@ -21,7 +22,7 @@ func init() {
defaultInstallConfig := configStructs.InstallConfig{}
if err := defaults.Set(&defaultInstallConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
installCmd.Flags().BoolP(configStructs.OutInstallName, "o", defaultInstallConfig.Out, "print (to stdout) Kubernetes manifest used to install Kubeshark Pro edition")

8
cli/cmd/installRunner.go → cmd/installRunner.go
View File

@ -2,11 +2,11 @@ package cmd
import (
"fmt"
"log"
"strings"
"github.com/kubeshark/kubeshark/cli/bucket"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/bucket"
"github.com/kubeshark/kubeshark/config"
)
func runKubesharkInstall() {
@ -15,7 +15,7 @@ func runKubesharkInstall() {
bucketProvider := bucket.NewProvider(config.Config.Install.TemplateUrl, bucket.DefaultTimeout)
installTemplate, err := bucketProvider.GetInstallTemplate(config.Config.Install.TemplateName)
if err != nil {
logger.Log.Errorf("Failed getting install template, err: %v", err)
log.Printf("Failed getting install template, err: %v", err)
return
}

16
cli/cmd/logs.go → cmd/logs.go
View File

@ -2,13 +2,13 @@ package cmd
import (
"context"
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/kubeshark/kubeshark/kubeshark/fsUtils"
"github.com/spf13/cobra"
)
@ -26,10 +26,10 @@ var logsCmd = &cobra.Command{
return errormessage.FormatError(validationErr)
}
logger.Log.Debugf("Using file path %s", config.Config.Logs.FilePath())
log.Printf("Using file path %s", config.Config.Logs.FilePath())
if dumpLogsErr := fsUtils.DumpLogs(ctx, kubernetesProvider, config.Config.Logs.FilePath()); dumpLogsErr != nil {
logger.Log.Errorf("Failed dump logs %v", dumpLogsErr)
log.Printf("Failed dump logs %v", dumpLogsErr)
}
return nil
@ -41,7 +41,7 @@ func init() {
defaultLogsConfig := configStructs.LogsConfig{}
if err := defaults.Set(&defaultLogsConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
logsCmd.Flags().StringP(configStructs.FileLogsName, "f", defaultLogsConfig.FileStr, "Path for zip file (default current <pwd>\\kubeshark_logs.zip)")

0
cli/cmd/permissionFiles/permissions-all-namespaces-debug-optional.yaml → cmd/permissionFiles/permissions-all-namespaces-debug-optional.yaml
View File

0
cli/cmd/permissionFiles/permissions-all-namespaces-ip-resolution-optional.yaml → cmd/permissionFiles/permissions-all-namespaces-ip-resolution-optional.yaml
View File

0
cli/cmd/permissionFiles/permissions-all-namespaces-tap.yaml → cmd/permissionFiles/permissions-all-namespaces-tap.yaml
View File

0
cli/cmd/permissionFiles/permissions-ns-debug-optional.yaml → cmd/permissionFiles/permissions-ns-debug-optional.yaml
View File

0
cli/cmd/permissionFiles/permissions-ns-ip-resolution-optional.yaml → cmd/permissionFiles/permissions-ns-ip-resolution-optional.yaml
View File

0
cli/cmd/permissionFiles/permissions-ns-tap.yaml → cmd/permissionFiles/permissions-ns-tap.yaml
View File

21
cli/cmd/root.go → cmd/root.go
View File

@ -2,15 +2,13 @@ package cmd
import (
"fmt"
"log"
"time"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/cli/kubeshark/version"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubeshark/version"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/spf13/cobra"
)
@ -21,7 +19,7 @@ var rootCmd = &cobra.Command{
Further info is available at https://github.com/kubeshark/kubeshark`,
PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
if err := config.InitConfig(cmd); err != nil {
logger.Log.Fatal(err)
log.Fatal(err)
}
return nil
@ -31,7 +29,7 @@ Further info is available at https://github.com/kubeshark/kubeshark`,
func init() {
defaultConfig := config.CreateDefaultConfig()
if err := defaults.Set(&defaultConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
rootCmd.PersistentFlags().StringSlice(config.SetCommandName, []string{}, fmt.Sprintf("Override values using --%s", config.SetCommandName))
@ -42,7 +40,7 @@ func printNewVersionIfNeeded(versionChan chan string) {
select {
case versionMsg := <-versionChan:
if versionMsg != "" {
logger.Log.Infof(uiUtils.Yellow, versionMsg)
log.Printf(uiUtils.Yellow, versionMsg)
}
case <-time.After(2 * time.Second):
}
@ -51,11 +49,6 @@ func printNewVersionIfNeeded(versionChan chan string) {
// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the tapCmd.
func Execute() {
if err := fsUtils.EnsureDir(kubeshark.GetKubesharkFolderPath()); err != nil {
logger.Log.Errorf("Failed to use kubeshark folder, %v", err)
}
logger.InitLogger(fsUtils.GetLogFilePath())
versionChan := make(chan string)
defer printNewVersionIfNeeded(versionChan)
go version.CheckNewerVersion(versionChan)

12
cli/cmd/tap.go → cmd/tap.go
View File

@ -2,12 +2,12 @@ package cmd
import (
"errors"
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/spf13/cobra"
)
@ -31,7 +31,7 @@ Supported protocols are HTTP and gRPC.`,
return errormessage.FormatError(err)
}
logger.Log.Infof("Kubeshark will store up to %s of traffic, old traffic will be cleared once the limit is reached.", config.Config.Tap.HumanMaxEntriesDBSize)
log.Printf("Kubeshark will store up to %s of traffic, old traffic will be cleared once the limit is reached.", config.Config.Tap.HumanMaxEntriesDBSize)
return nil
},
@ -42,7 +42,7 @@ func init() {
defaultTapConfig := configStructs.TapConfig{}
if err := defaults.Set(&defaultTapConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
tapCmd.Flags().Uint16P(configStructs.GuiPortTapName, "p", defaultTapConfig.GuiPort, "Provide a custom port for the web interface webserver")

129
cli/cmd/tapRunner.go → cmd/tapRunner.go
View File

@ -4,27 +4,27 @@ import (
"context"
"errors"
"fmt"
"log"
"regexp"
"strings"
"time"
"github.com/kubeshark/kubeshark/cli/resources"
"github.com/kubeshark/kubeshark/cli/utils"
"github.com/kubeshark/kubeshark/resources"
"github.com/kubeshark/kubeshark/utils"
core "k8s.io/api/core/v1"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/kubeshark/kubeshark/cli/apiserver"
"github.com/kubeshark/kubeshark/cli/cmd/goUtils"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/apiserver"
"github.com/kubeshark/kubeshark/cmd/goUtils"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/worker/api"
"github.com/kubeshark/worker/models"
)
const cleanupTimeout = time.Minute
@ -59,43 +59,43 @@ func RunKubesharkTap() {
kubesharkAgentConfig := getTapKubesharkAgentConfig()
serializedKubesharkConfig, err := getSerializedKubesharkAgentConfig(kubesharkAgentConfig)
if err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error serializing kubeshark config: %v", errormessage.FormatError(err)))
log.Printf(uiUtils.Error, fmt.Sprintf("Error serializing kubeshark config: %v", errormessage.FormatError(err)))
return
}
if config.Config.IsNsRestrictedMode() {
if len(state.targetNamespaces) != 1 || !shared.Contains(state.targetNamespaces, config.Config.KubesharkResourcesNamespace) {
logger.Log.Errorf("Not supported mode. Kubeshark can't resolve IPs in other namespaces when running in namespace restricted mode.\n"+
if len(state.targetNamespaces) != 1 || !utils.Contains(state.targetNamespaces, config.Config.KubesharkResourcesNamespace) {
log.Printf("Not supported mode. Kubeshark can't resolve IPs in other namespaces when running in namespace restricted mode.\n"+
"You can use the same namespace for --%s and --%s", configStructs.NamespacesTapName, config.KubesharkResourcesNamespaceConfigName)
return
}
}
var namespacesStr string
if !shared.Contains(state.targetNamespaces, kubernetes.K8sAllNamespaces) {
if !utils.Contains(state.targetNamespaces, kubernetes.K8sAllNamespaces) {
namespacesStr = fmt.Sprintf("namespaces \"%s\"", strings.Join(state.targetNamespaces, "\", \""))
} else {
namespacesStr = "all namespaces"
}
logger.Log.Infof("Tapping pods in %s", namespacesStr)
log.Printf("Tapping pods in %s", namespacesStr)
if err := printTappedPodsPreview(ctx, kubernetesProvider, state.targetNamespaces); err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error listing pods: %v", errormessage.FormatError(err)))
log.Printf(uiUtils.Error, fmt.Sprintf("Error listing pods: %v", errormessage.FormatError(err)))
}
if config.Config.Tap.DryRun {
return
}
logger.Log.Infof("Waiting for Kubeshark Agent to start...")
log.Printf("Waiting for Kubeshark Agent to start...")
if state.kubesharkServiceAccountExists, err = resources.CreateTapKubesharkResources(ctx, kubernetesProvider, serializedKubesharkConfig, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace, config.Config.AgentImage, config.Config.Tap.MaxEntriesDBSizeBytes(), config.Config.Tap.ApiServerResources, config.Config.ImagePullPolicy(), config.Config.LogLevel(), config.Config.Tap.Profiler); err != nil {
var statusError *k8serrors.StatusError
if errors.As(err, &statusError) && (statusError.ErrStatus.Reason == metav1.StatusReasonAlreadyExists) {
logger.Log.Info("Kubeshark is already running in this namespace, change the `kubeshark-resources-namespace` configuration or run `kubeshark clean` to remove the currently running Kubeshark instance")
log.Print("Kubeshark is already running in this namespace, change the `kubeshark-resources-namespace` configuration or run `kubeshark clean` to remove the currently running Kubeshark instance")
} else {
defer resources.CleanUpKubesharkResources(ctx, cancel, kubernetesProvider, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace)
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err)))
log.Printf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err)))
}
return
@ -115,8 +115,8 @@ func finishTapExecution(kubernetesProvider *kubernetes.Provider) {
finishKubesharkExecution(kubernetesProvider, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace)
}
func getTapKubesharkAgentConfig() *shared.KubesharkAgentConfig {
kubesharkAgentConfig := shared.KubesharkAgentConfig{
func getTapKubesharkAgentConfig() *models.Config {
kubesharkAgentConfig := models.Config{
MaxDBSizeBytes: config.Config.Tap.MaxEntriesDBSizeBytes(),
InsertionFilter: config.Config.Tap.GetInsertionFilter(),
AgentImage: config.Config.AgentImage,
@ -124,7 +124,7 @@ func getTapKubesharkAgentConfig() *shared.KubesharkAgentConfig {
LogLevel: config.Config.LogLevel(),
TapperResources: config.Config.Tap.TapperResources,
KubesharkResourcesNamespace: config.Config.KubesharkResourcesNamespace,
AgentDatabasePath: shared.DataDirPath,
AgentDatabasePath: models.DataDirPath,
ServiceMap: config.Config.ServiceMap,
OAS: config.Config.OAS,
}
@ -145,7 +145,7 @@ func printTappedPodsPreview(ctx context.Context, kubernetesProvider *kubernetes.
printNoPodsFoundSuggestion(namespaces)
}
for _, tappedPod := range matchingPods {
logger.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", tappedPod.Name))
log.Printf(uiUtils.Green, fmt.Sprintf("+%s", tappedPod.Name))
}
return nil
}
@ -178,29 +178,29 @@ func startTapperSyncer(ctx context.Context, cancel context.CancelFunc, provider
select {
case syncerErr, ok := <-tapperSyncer.ErrorOut:
if !ok {
logger.Log.Debug("kubesharkTapperSyncer err channel closed, ending listener loop")
log.Print("kubesharkTapperSyncer err channel closed, ending listener loop")
return
}
logger.Log.Errorf(uiUtils.Error, getErrorDisplayTextForK8sTapManagerError(syncerErr))
log.Printf(uiUtils.Error, getErrorDisplayTextForK8sTapManagerError(syncerErr))
cancel()
case _, ok := <-tapperSyncer.TapPodChangesOut:
if !ok {
logger.Log.Debug("kubesharkTapperSyncer pod changes channel closed, ending listener loop")
log.Print("kubesharkTapperSyncer pod changes channel closed, ending listener loop")
return
}
if err := apiProvider.ReportTappedPods(tapperSyncer.CurrentlyTappedPods); err != nil {
logger.Log.Debugf("[Error] failed update tapped pods %v", err)
log.Printf("[Error] failed update tapped pods %v", err)
}
case tapperStatus, ok := <-tapperSyncer.TapperStatusChangedOut:
if !ok {
logger.Log.Debug("kubesharkTapperSyncer tapper status changed channel closed, ending listener loop")
log.Print("kubesharkTapperSyncer tapper status changed channel closed, ending listener loop")
return
}
if err := apiProvider.ReportTapperStatus(tapperStatus); err != nil {
logger.Log.Debugf("[Error] failed update tapper status %v", err)
log.Printf("[Error] failed update tapper status %v", err)
}
case <-ctx.Done():
logger.Log.Debug("kubesharkTapperSyncer event listener loop exiting due to context done")
log.Print("kubesharkTapperSyncer event listener loop exiting due to context done")
return
}
}
@ -211,10 +211,10 @@ func startTapperSyncer(ctx context.Context, cancel context.CancelFunc, provider
func printNoPodsFoundSuggestion(targetNamespaces []string) {
var suggestionStr string
if !shared.Contains(targetNamespaces, kubernetes.K8sAllNamespaces) {
if !utils.Contains(targetNamespaces, kubernetes.K8sAllNamespaces) {
suggestionStr = ". You can also try selecting a different namespace with -n or tap all namespaces with -A"
}
logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Did not find any currently running pods that match the regex argument, kubeshark will automatically tap matching pods if any are created later%s", suggestionStr))
log.Printf(uiUtils.Warning, fmt.Sprintf("Did not find any currently running pods that match the regex argument, kubeshark will automatically tap matching pods if any are created later%s", suggestionStr))
}
func getErrorDisplayTextForK8sTapManagerError(err kubernetes.K8sTapManagerError) string {
@ -248,20 +248,20 @@ func watchApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
switch wEvent.Type {
case kubernetes.EventAdded:
logger.Log.Debugf("Watching API Server pod loop, added")
log.Printf("Watching API Server pod loop, added")
case kubernetes.EventDeleted:
logger.Log.Infof("%s removed", kubernetes.ApiServerPodName)
log.Printf("%s removed", kubernetes.ApiServerPodName)
cancel()
return
case kubernetes.EventModified:
modifiedPod, err := wEvent.ToPod()
if err != nil {
logger.Log.Errorf(uiUtils.Error, err)
log.Printf(uiUtils.Error, err)
cancel()
continue
}
logger.Log.Debugf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
log.Printf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
if modifiedPod.Status.Phase == core.PodRunning && !isPodReady {
isPodReady = true
@ -284,16 +284,16 @@ func watchApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
continue
}
logger.Log.Errorf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
log.Printf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
cancel()
case <-timeAfter:
if !isPodReady {
logger.Log.Errorf(uiUtils.Error, "Kubeshark API server was not ready in time")
log.Printf(uiUtils.Error, "Kubeshark API server was not ready in time")
cancel()
}
case <-ctx.Done():
logger.Log.Debugf("Watching API Server pod loop, ctx done")
log.Printf("Watching API Server pod loop, ctx done")
return
}
}
@ -317,20 +317,20 @@ func watchFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider,
switch wEvent.Type {
case kubernetes.EventAdded:
logger.Log.Debugf("Watching API Server pod loop, added")
log.Printf("Watching API Server pod loop, added")
case kubernetes.EventDeleted:
logger.Log.Infof("%s removed", "front")
log.Printf("%s removed", "front")
cancel()
return
case kubernetes.EventModified:
modifiedPod, err := wEvent.ToPod()
if err != nil {
logger.Log.Errorf(uiUtils.Error, err)
log.Printf(uiUtils.Error, err)
cancel()
continue
}
logger.Log.Debugf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
log.Printf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
if modifiedPod.Status.Phase == core.PodRunning && !isPodReady {
isPodReady = true
@ -352,16 +352,16 @@ func watchFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider,
continue
}
logger.Log.Errorf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
log.Printf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
cancel()
case <-timeAfter:
if !isPodReady {
logger.Log.Errorf(uiUtils.Error, "Kubeshark API server was not ready in time")
log.Printf(uiUtils.Error, "Kubeshark API server was not ready in time")
cancel()
}
case <-ctx.Done():
logger.Log.Debugf("Watching API Server pod loop, ctx done")
log.Printf("Watching API Server pod loop, ctx done")
return
}
}
@ -381,7 +381,7 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
event, err := wEvent.ToEvent()
if err != nil {
logger.Log.Debugf("[ERROR] parsing Kubeshark resource event: %+v", err)
log.Printf("[ERROR] parsing Kubeshark resource event: %+v", err)
continue
}
@ -389,18 +389,19 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
continue
}
logger.Log.Debugf(
fmt.Sprintf("Watching API server events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
event.Name,
event.CreationTimestamp.Time,
event.Regarding.Name,
event.Regarding.Kind,
event.Reason,
event.Note))
log.Printf(
"Watching API server events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
event.Name,
event.CreationTimestamp.Time,
event.Regarding.Name,
event.Regarding.Kind,
event.Reason,
event.Note,
)
switch event.Reason {
case "FailedScheduling", "Failed":
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Kubeshark API Server status: %s - %s", event.Reason, event.Note))
log.Printf(uiUtils.Error, fmt.Sprintf("Kubeshark API Server status: %s - %s", event.Reason, event.Note))
cancel()
}
@ -410,9 +411,9 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
continue
}
logger.Log.Debugf("[Error] Watching API server events loop, error: %+v", err)
log.Printf("[Error] Watching API server events loop, error: %+v", err)
case <-ctx.Done():
logger.Log.Debugf("Watching API server events loop, ctx done")
log.Printf("Watching API server events loop, ctx done")
return
}
}
@ -422,19 +423,19 @@ func postApiServerStarted(ctx context.Context, kubernetesProvider *kubernetes.Pr
startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "kubeshark-api-server", config.Config.Hub.PortForward.SrcPort, config.Config.Hub.PortForward.DstPort, "/echo")
if err := startTapperSyncer(ctx, cancel, kubernetesProvider, state.targetNamespaces, state.startTime); err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error starting kubeshark tapper syncer: %v", errormessage.FormatError(err)))
log.Printf(uiUtils.Error, fmt.Sprintf("Error starting kubeshark tapper syncer: %v", errormessage.FormatError(err)))
cancel()
}
url := kubernetes.GetLocalhostOnPort(config.Config.Hub.PortForward.SrcPort)
logger.Log.Infof("API Server is available at %s", url)
log.Printf("API Server is available at %s", url)
}
func postFrontStarted(ctx context.Context, kubernetesProvider *kubernetes.Provider, cancel context.CancelFunc) {
startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "front", config.Config.Front.PortForward.SrcPort, config.Config.Front.PortForward.DstPort, "")
url := kubernetes.GetLocalhostOnPort(config.Config.Front.PortForward.SrcPort)
logger.Log.Infof("Kubeshark is available at %s", url)
log.Printf("Kubeshark is available at %s", url)
if !config.Config.HeadlessMode {
uiUtils.OpenBrowser(url)
}
@ -444,11 +445,11 @@ func getNamespaces(kubernetesProvider *kubernetes.Provider) []string {
if config.Config.Tap.AllNamespaces {
return []string{kubernetes.K8sAllNamespaces}
} else if len(config.Config.Tap.Namespaces) > 0 {
return shared.Unique(config.Config.Tap.Namespaces)
return utils.Unique(config.Config.Tap.Namespaces)
} else {
currentNamespace, err := kubernetesProvider.CurrentNamespace()
if err != nil {
logger.Log.Fatalf(uiUtils.Red, fmt.Sprintf("error getting current namespace: %+v", err))
log.Fatalf(uiUtils.Red, fmt.Sprintf("error getting current namespace: %+v", err))
}
return []string{currentNamespace}
}

16
cli/cmd/version.go → cmd/version.go
View File

@ -1,15 +1,15 @@
package cmd
import (
"log"
"strconv"
"time"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/kubeshark"
"github.com/spf13/cobra"
)
@ -19,11 +19,11 @@ var versionCmd = &cobra.Command{
RunE: func(cmd *cobra.Command, args []string) error {
if config.Config.Version.DebugInfo {
timeStampInt, _ := strconv.ParseInt(kubeshark.BuildTimestamp, 10, 0)
logger.Log.Infof("Version: %s \nBranch: %s (%s)", kubeshark.Ver, kubeshark.Branch, kubeshark.GitCommitHash)
logger.Log.Infof("Build Time: %s (%s)", kubeshark.BuildTimestamp, time.Unix(timeStampInt, 0))
log.Printf("Version: %s \nBranch: %s (%s)", kubeshark.Ver, kubeshark.Branch, kubeshark.GitCommitHash)
log.Printf("Build Time: %s (%s)", kubeshark.BuildTimestamp, time.Unix(timeStampInt, 0))
} else {
logger.Log.Infof("Version: %s (%s)", kubeshark.Ver, kubeshark.Branch)
log.Printf("Version: %s (%s)", kubeshark.Ver, kubeshark.Branch)
}
return nil
},
@ -34,7 +34,7 @@ func init() {
defaultVersionConfig := configStructs.VersionConfig{}
if err := defaults.Set(&defaultVersionConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
versionCmd.Flags().BoolP(configStructs.DebugInfoVersionName, "d", defaultVersionConfig.DebugInfo, "Provide all information about version")

9
cli/cmd/view.go → cmd/view.go
View File

@ -1,9 +1,10 @@
package cmd
import (
"log"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/spf13/cobra"
)
@ -21,13 +22,13 @@ func init() {
defaultViewConfig := configStructs.ViewConfig{}
if err := defaults.Set(&defaultViewConfig); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
viewCmd.Flags().Uint16P(configStructs.GuiPortViewName, "p", defaultViewConfig.GuiPort, "Provide a custom port for the web interface webserver")
viewCmd.Flags().StringP(configStructs.UrlViewName, "u", defaultViewConfig.Url, "Provide a custom host")
if err := viewCmd.Flags().MarkHidden(configStructs.UrlViewName); err != nil {
logger.Log.Debug(err)
log.Print(err)
}
}

25
cli/cmd/viewRunner.go → cmd/viewRunner.go
View File

@ -3,16 +3,15 @@ package cmd
import (
"context"
"fmt"
"log"
"net/http"
"github.com/kubeshark/kubeshark/cli/utils"
"github.com/kubeshark/kubeshark/utils"
"github.com/kubeshark/kubeshark/cli/apiserver"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/apiserver"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
)
func runKubesharkView() {
@ -29,12 +28,12 @@ func runKubesharkView() {
if url == "" {
exists, err := kubernetesProvider.DoesServiceExist(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.ApiServerPodName)
if err != nil {
logger.Log.Errorf("Failed to found kubeshark service %v", err)
log.Printf("Failed to found kubeshark service %v", err)
cancel()
return
}
if !exists {
logger.Log.Infof("%s service not found, you should run `kubeshark tap` command first", kubernetes.ApiServerPodName)
log.Printf("%s service not found, you should run `kubeshark tap` command first", kubernetes.ApiServerPodName)
cancel()
return
}
@ -43,20 +42,20 @@ func runKubesharkView() {
response, err := http.Get(fmt.Sprintf("%s/", url))
if err == nil && response.StatusCode == 200 {
logger.Log.Infof("Found a running service %s and open port %d", kubernetes.ApiServerPodName, config.Config.Front.PortForward.SrcPort)
log.Printf("Found a running service %s and open port %d", kubernetes.ApiServerPodName, config.Config.Front.PortForward.SrcPort)
return
}
logger.Log.Infof("Establishing connection to k8s cluster...")
log.Printf("Establishing connection to k8s cluster...")
startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "front", config.Config.Front.PortForward.SrcPort, config.Config.Front.PortForward.DstPort, "")
}
apiServerProvider := apiserver.NewProvider(url, apiserver.DefaultRetries, apiserver.DefaultTimeout)
if err := apiServerProvider.TestConnection(""); err != nil {
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Couldn't connect to API server, for more info check logs at %s", fsUtils.GetLogFilePath()))
log.Printf(uiUtils.Error, "Couldn't connect to API server.")
return
}
logger.Log.Infof("Kubeshark is available at %s", url)
log.Printf("Kubeshark is available at %s", url)
if !config.Config.HeadlessMode {
uiUtils.OpenBrowser(url)

19
cli/config/config.go → config/config.go
View File

@ -4,16 +4,15 @@ import (
"errors"
"fmt"
"io"
"log"
"os"
"reflect"
"strconv"
"strings"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/creasty/defaults"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/kubeshark/utils"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"gopkg.in/yaml.v3"
@ -67,7 +66,7 @@ func InitConfig(cmd *cobra.Command) error {
}
finalConfigPrettified, _ := uiUtils.PrettyJson(Config)
logger.Log.Debugf("Init config finished\n Final config: %v", finalConfigPrettified)
log.Printf("Init config finished\n Final config: %v", finalConfigPrettified)
return nil
}
@ -113,7 +112,7 @@ func loadConfigFile(configFilePath string, config *ConfigStruct) error {
return err
}
logger.Log.Debugf("Found config file, config path: %s", configFilePath)
log.Printf("Found config file, config path: %s", configFilePath)
return nil
}
@ -122,7 +121,7 @@ func initFlag(f *pflag.Flag) {
configElemValue := reflect.ValueOf(&Config).Elem()
var flagPath []string
if shared.Contains([]string{ConfigFilePathCommandName}, f.Name) {
if utils.Contains([]string{ConfigFilePathCommandName}, f.Name) {
flagPath = []string{f.Name}
} else {
flagPath = []string{cmdName, f.Name}
@ -131,20 +130,20 @@ func initFlag(f *pflag.Flag) {
sliceValue, isSliceValue := f.Value.(pflag.SliceValue)
if !isSliceValue {
if err := mergeFlagValue(configElemValue, flagPath, strings.Join(flagPath, "."), f.Value.String()); err != nil {
logger.Log.Warningf(uiUtils.Warning, err)
log.Printf(uiUtils.Warning, err)
}
return
}
if f.Name == SetCommandName {
if err := mergeSetFlag(configElemValue, sliceValue.GetSlice()); err != nil {
logger.Log.Warningf(uiUtils.Warning, err)
log.Printf(uiUtils.Warning, err)
}
return
}
if err := mergeFlagValues(configElemValue, flagPath, strings.Join(flagPath, "."), sliceValue.GetSlice()); err != nil {
logger.Log.Warningf(uiUtils.Warning, err)
log.Printf(uiUtils.Warning, err)
}
}

11
cli/config/configStruct.go → config/configStruct.go
View File

@ -6,9 +6,10 @@ import (
"path"
"path/filepath"
"github.com/kubeshark/kubeshark/cli/config/configStructs"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/config/configStructs"
"github.com/kubeshark/kubeshark/kubeshark"
"github.com/kubeshark/kubeshark/utils"
"github.com/kubeshark/worker/models"
"github.com/op/go-logging"
v1 "k8s.io/api/core/v1"
"k8s.io/client-go/util/homedir"
@ -73,7 +74,7 @@ type ConfigStruct struct {
HeadlessMode bool `yaml:"headless" default:"false"`
LogLevelStr string `yaml:"log-level,omitempty" default:"INFO" readonly:""`
ServiceMap bool `yaml:"service-map" default:"true"`
OAS shared.OASConfig `yaml:"oas"`
OAS models.OASConfig `yaml:"oas"`
}
func (config *ConfigStruct) validate() error {
@ -85,7 +86,7 @@ func (config *ConfigStruct) validate() error {
}
func (config *ConfigStruct) SetDefaults() {
config.AgentImage = fmt.Sprintf("%s:%s", shared.KubesharkAgentImageRepo, kubeshark.Ver)
config.AgentImage = fmt.Sprintf("%s:%s", utils.KubesharkAgentImageRepo, kubeshark.Ver)
config.ConfigFilePath = path.Join(kubeshark.GetKubesharkFolderPath(), "config.yaml")
}

0
cli/config/configStructs/checkConfig.go → config/configStructs/checkConfig.go
View File

0
cli/config/configStructs/configConfig.go → config/configStructs/configConfig.go
View File

0
cli/config/configStructs/installConfig.go → config/configStructs/installConfig.go
View File

0
cli/config/configStructs/logsConfig.go → config/configStructs/logsConfig.go
View File

14
cli/config/configStructs/tapConfig.go → config/configStructs/tapConfig.go
View File

@ -3,15 +3,15 @@ package configStructs
import (
"fmt"
"io/fs"
"log"
"os"
"regexp"
"strings"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/worker/models"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/units"
"github.com/kubeshark/kubeshark/units"
)
const (
@ -46,8 +46,8 @@ type TapConfig struct {
HumanMaxEntriesDBSize string `yaml:"max-entries-db-size" default:"200MB"`
InsertionFilter string `yaml:"insertion-filter" default:""`
DryRun bool `yaml:"dry-run" default:"false"`
ApiServerResources shared.Resources `yaml:"api-server-resources"`
TapperResources shared.Resources `yaml:"tapper-resources"`
ApiServerResources models.Resources `yaml:"api-server-resources"`
TapperResources models.Resources `yaml:"tapper-resources"`
ServiceMesh bool `yaml:"service-mesh" default:"false"`
Tls bool `yaml:"tls" default:"false"`
PacketCapture string `yaml:"packet-capture" default:"libpcap"`
@ -71,7 +71,7 @@ func (config *TapConfig) GetInsertionFilter() string {
if _, err := os.Stat(insertionFilter); err == nil {
b, err := os.ReadFile(insertionFilter)
if err != nil {
logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Couldn't read the file on path: %s, err: %v", insertionFilter, err))
log.Printf(uiUtils.Warning, fmt.Sprintf("Couldn't read the file on path: %s, err: %v", insertionFilter, err))
} else {
insertionFilter = string(b)
}

0
cli/config/configStructs/versionConfig.go → config/configStructs/versionConfig.go
View File

0
cli/config/configStructs/viewConfig.go → config/configStructs/viewConfig.go
View File

0
cli/config/config_internal_test.go → config/config_internal_test.go
View File

5
cli/config/config_test.go → config/config_test.go
View File

@ -2,11 +2,12 @@ package config_test
import (
"fmt"
"github.com/kubeshark/kubeshark/cli/config"
"gopkg.in/yaml.v3"
"reflect"
"strings"
"testing"
"github.com/kubeshark/kubeshark/config"
"gopkg.in/yaml.v3"
)
func TestConfigWriteIgnoresReadonlyFields(t *testing.T) {

0
cli/config/envConfig.go → config/envConfig.go
View File

0
shared/debounce/debounce.go → debounce/debounce.go
View File

2
cli/errormessage/errormessage.go → errormessage/errormessage.go
View File

@ -5,7 +5,7 @@ import (
"fmt"
regexpsyntax "regexp/syntax"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/config"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
)

15
cli/go.mod → go.mod
View File

@ -1,13 +1,12 @@
module github.com/kubeshark/kubeshark/cli
module github.com/kubeshark/kubeshark
go 1.17
require (
github.com/creasty/defaults v1.5.2
github.com/docker/go-units v0.4.0
github.com/google/go-github/v37 v37.0.0
github.com/kubeshark/kubeshark/logger v0.0.0
github.com/kubeshark/kubeshark/shared v0.0.0
github.com/kubeshark/worker v0.1.1
github.com/kubeshark/worker v0.1.4
github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
github.com/spf13/cobra v1.3.0
github.com/spf13/pflag v1.0.5
@ -15,6 +14,7 @@ require (
k8s.io/api v0.23.3
k8s.io/apimachinery v0.23.3
k8s.io/client-go v0.23.3
k8s.io/kubectl v0.23.3
)
require (
@ -31,7 +31,6 @@ require (
github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/docker/go-units v0.4.0 // indirect
github.com/evanphx/json-patch v5.6.0+incompatible // indirect
github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
github.com/fvbommel/sortorder v1.0.2 // indirect
@ -69,6 +68,7 @@ require (
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/russross/blackfriday v1.6.0 // indirect
github.com/stretchr/testify v1.7.0 // indirect
github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51 // indirect
github.com/xlab/treeprint v1.1.0 // indirect
go.starlark.net v0.0.0-20220203230714-bb14e151c28f // indirect
golang.org/x/crypto v0.0.0-20220208050332-20e1d8d225ab // indirect
@ -86,7 +86,6 @@ require (
k8s.io/component-base v0.23.3 // indirect
k8s.io/klog/v2 v2.40.1 // indirect
k8s.io/kube-openapi v0.0.0-20220124234850-424119656bbf // indirect
k8s.io/kubectl v0.23.3 // indirect
k8s.io/utils v0.0.0-20220127004650-9b3446523e65 // indirect
sigs.k8s.io/json v0.0.0-20211208200746-9f7c6b3444d2 // indirect
sigs.k8s.io/kustomize/api v0.11.1 // indirect
@ -94,7 +93,3 @@ require (
sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
sigs.k8s.io/yaml v1.3.0 // indirect
)
replace github.com/kubeshark/kubeshark/logger v0.0.0 => ../logger
replace github.com/kubeshark/kubeshark/shared v0.0.0 => ../shared

5
cli/go.sum → go.sum
View File

@ -423,8 +423,8 @@ 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/kubeshark/worker v0.1.1 h1:asXRzJWZHVlbanihsk8ycCwnEJDmr611VQtA/KVDeDg=
github.com/kubeshark/worker v0.1.1/go.mod h1:tvLnSvCKq7D8KB1RTYXybvHGkusBaHEFpv1ya4sgUAw=
github.com/kubeshark/worker v0.1.4 h1:N6Lfy74efzsVK9MqHNqRtJv+iHUH/8/ri2drDgC7HsA=
github.com/kubeshark/worker v0.1.4/go.mod h1:VuTJRuOuercnTyYZCwuW/+f4BSjqh6CnBWqsRwY4Xic=
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/lithammer/dedent v1.1.0/go.mod h1:jrXYCQtgg0nJiN+StA2KgR7w6CiQNv9Fd/Z9BP0jIOc=
@ -614,6 +614,7 @@ github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hM
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51 h1:6op+PUYmTlxze3V3f30lWKix3sWqv1M9rvRhyaxbsdQ=
github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51/go.mod h1:SvJGPoa/6erhUQV7kvHBwM/0x5LyO6XaG2lUaCaKiUI=
github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=

0
shared/kubernetes/consts.go → kubernetes/consts.go
View File

0
shared/kubernetes/errors.go → kubernetes/errors.go
View File

0
shared/kubernetes/eventWatchHelper.go → kubernetes/eventWatchHelper.go
View File

84
shared/kubernetes/kubesharkTapperSyncer.go → kubernetes/kubesharkTapperSyncer.go
View File

@ -3,13 +3,14 @@ package kubernetes
import (
"context"
"fmt"
"log"
"regexp"
"time"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/shared/debounce"
"github.com/kubeshark/kubeshark/debounce"
"github.com/kubeshark/kubeshark/utils"
"github.com/kubeshark/worker/api"
"github.com/kubeshark/worker/models"
"github.com/op/go-logging"
core "k8s.io/api/core/v1"
)
@ -29,9 +30,9 @@ type KubesharkTapperSyncer struct {
config TapperSyncerConfig
kubernetesProvider *Provider
TapPodChangesOut chan TappedPodChangeEvent
TapperStatusChangedOut chan shared.TapperStatus
TapperStatusChangedOut chan models.TapperStatus
ErrorOut chan K8sTapManagerError
nodeToTappedPodMap shared.NodeToPodsMap
nodeToTappedPodMap models.NodeToPodsMap
tappedNodes []string
}
@ -40,7 +41,7 @@ type TapperSyncerConfig struct {
PodFilterRegex regexp.Regexp
KubesharkResourcesNamespace string
AgentImage string
TapperResources shared.Resources
TapperResources models.Resources
ImagePullPolicy core.PullPolicy
LogLevel logging.Level
KubesharkApiFilteringOptions api.TrafficFilteringOptions
@ -58,7 +59,7 @@ func CreateAndStartKubesharkTapperSyncer(ctx context.Context, kubernetesProvider
config: config,
kubernetesProvider: kubernetesProvider,
TapPodChangesOut: make(chan TappedPodChangeEvent, 100),
TapperStatusChangedOut: make(chan shared.TapperStatus, 100),
TapperStatusChangedOut: make(chan models.TapperStatus, 100),
ErrorOut: make(chan K8sTapManagerError, 100),
}
@ -91,13 +92,13 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperPods() {
pod, err := wEvent.ToPod()
if err != nil {
logger.Log.Debugf("[ERROR] parsing Kubeshark resource pod: %+v", err)
log.Printf("[ERROR] parsing Kubeshark resource pod: %+v", err)
continue
}
logger.Log.Debugf("Watching tapper pods loop, tapper: %v, node: %v, status: %v", pod.Name, pod.Spec.NodeName, pod.Status.Phase)
log.Printf("Watching tapper pods loop, tapper: %v, node: %v, status: %v", pod.Name, pod.Spec.NodeName, pod.Status.Phase)
if pod.Spec.NodeName != "" {
tapperStatus := shared.TapperStatus{TapperName: pod.Name, NodeName: pod.Spec.NodeName, Status: string(pod.Status.Phase)}
tapperStatus := models.TapperStatus{TapperName: pod.Name, NodeName: pod.Spec.NodeName, Status: string(pod.Status.Phase)}
tapperSyncer.TapperStatusChangedOut <- tapperStatus
}
@ -106,10 +107,10 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperPods() {
errorChan = nil
continue
}
logger.Log.Debugf("[ERROR] Watching tapper pods loop, error: %+v", err)
log.Printf("[ERROR] Watching tapper pods loop, error: %+v", err)
case <-tapperSyncer.context.Done():
logger.Log.Debugf("Watching tapper pods loop, ctx done")
log.Printf("Watching tapper pods loop, ctx done")
return
}
}
@ -130,22 +131,23 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
event, err := wEvent.ToEvent()
if err != nil {
logger.Log.Debugf("[ERROR] parsing Kubeshark resource event: %+v", err)
log.Printf("[ERROR] parsing Kubeshark resource event: %+v", err)
continue
}
logger.Log.Debugf(
fmt.Sprintf("Watching tapper events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
event.Name,
event.CreationTimestamp.Time,
event.Regarding.Name,
event.Regarding.Kind,
event.Reason,
event.Note))
log.Printf(
"Watching tapper events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
event.Name,
event.CreationTimestamp.Time,
event.Regarding.Name,
event.Regarding.Kind,
event.Reason,
event.Note,
)
pod, err1 := tapperSyncer.kubernetesProvider.GetPod(tapperSyncer.context, tapperSyncer.config.KubesharkResourcesNamespace, event.Regarding.Name)
if err1 != nil {
logger.Log.Debugf(fmt.Sprintf("Couldn't get tapper pod %s", event.Regarding.Name))
log.Printf("Couldn't get tapper pod %s", event.Regarding.Name)
continue
}
@ -156,7 +158,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
nodeName = pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchFields[0].Values[0]
}
tapperStatus := shared.TapperStatus{TapperName: pod.Name, NodeName: nodeName, Status: string(pod.Status.Phase)}
tapperStatus := models.TapperStatus{TapperName: pod.Name, NodeName: nodeName, Status: string(pod.Status.Phase)}
tapperSyncer.TapperStatusChangedOut <- tapperStatus
case err, ok := <-errorChan:
@ -165,10 +167,10 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
continue
}
logger.Log.Debugf("[ERROR] Watching tapper events loop, error: %+v", err)
log.Printf("[ERROR] Watching tapper events loop, error: %+v", err)
case <-tapperSyncer.context.Done():
logger.Log.Debugf("Watching tapper events loop, ctx done")
log.Printf("Watching tapper events loop, ctx done")
return
}
}
@ -188,7 +190,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
}
if !changeFound {
logger.Log.Debugf("Nothing changed update tappers not needed")
log.Printf("Nothing changed update tappers not needed")
return
}
if err := tapperSyncer.updateKubesharkTappers(); err != nil {
@ -216,17 +218,17 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
switch wEvent.Type {
case EventAdded:
logger.Log.Debugf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace)
log.Printf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace)
if err := restartTappersDebouncer.SetOn(); err != nil {
logger.Log.Error(err)
log.Print(err)
}
case EventDeleted:
logger.Log.Debugf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace)
log.Printf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace)
if err := restartTappersDebouncer.SetOn(); err != nil {
logger.Log.Error(err)
log.Print(err)
}
case EventModified:
logger.Log.Debugf("Modified matching pod %s, ns: %s, phase: %s, ip: %s", pod.Name, pod.Namespace, pod.Status.Phase, pod.Status.PodIP)
log.Printf("Modified matching pod %s, ns: %s, phase: %s, ip: %s", pod.Name, pod.Namespace, pod.Status.Phase, pod.Status.PodIP)
// Act only if the modified pod has already obtained an IP address.
// After filtering for IPs, on a normal pod restart this includes the following events:
// - Pod deletion
@ -235,7 +237,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
// Ready/unready transitions might also trigger this event.
if pod.Status.PodIP != "" {
if err := restartTappersDebouncer.SetOn(); err != nil {
logger.Log.Error(err)
log.Print(err)
}
}
case EventBookmark:
@ -253,7 +255,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
continue
case <-tapperSyncer.context.Done():
logger.Log.Debugf("Watching pods loop, context done, stopping `restart tappers debouncer`")
log.Printf("Watching pods loop, context done, stopping `restart tappers debouncer`")
restartTappersDebouncer.Cancel()
// TODO: Does this also perform cleanup?
return
@ -262,7 +264,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
}
func (tapperSyncer *KubesharkTapperSyncer) handleErrorInWatchLoop(err error, restartTappersDebouncer *debounce.Debouncer) {
logger.Log.Debugf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err)
log.Printf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err)
restartTappersDebouncer.Cancel()
tapperSyncer.ErrorOut <- K8sTapManagerError{
OriginalError: err,
@ -277,10 +279,10 @@ func (tapperSyncer *KubesharkTapperSyncer) updateCurrentlyTappedPods() (err erro
podsToTap := excludeKubesharkPods(matchingPods)
addedPods, removedPods := getPodArrayDiff(tapperSyncer.CurrentlyTappedPods, podsToTap)
for _, addedPod := range addedPods {
logger.Log.Debugf("tapping new pod %s", addedPod.Name)
log.Printf("tapping new pod %s", addedPod.Name)
}
for _, removedPod := range removedPods {
logger.Log.Debugf("pod %s is no longer running, tapping for it stopped", removedPod.Name)
log.Printf("pod %s is no longer running, tapping for it stopped", removedPod.Name)
}
if len(addedPods) > 0 || len(removedPods) > 0 {
tapperSyncer.CurrentlyTappedPods = podsToTap
@ -303,12 +305,12 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
i++
}
if shared.EqualStringSlices(nodesToTap, tapperSyncer.tappedNodes) {
logger.Log.Debug("Skipping apply, DaemonSet is up to date")
if utils.EqualStringSlices(nodesToTap, tapperSyncer.tappedNodes) {
log.Print("Skipping apply, DaemonSet is up to date")
return nil
}
logger.Log.Debugf("Updating DaemonSet to run on nodes: %v", nodesToTap)
log.Printf("Updating DaemonSet to run on nodes: %v", nodesToTap)
if len(tapperSyncer.nodeToTappedPodMap) > 0 {
var serviceAccountName string
@ -342,7 +344,7 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
return err
}
logger.Log.Debugf("Successfully created %v tappers", len(tapperSyncer.nodeToTappedPodMap))
log.Printf("Successfully created %v tappers", len(tapperSyncer.nodeToTappedPodMap))
} else {
if err := tapperSyncer.kubernetesProvider.ResetKubesharkTapperDaemonSet(
tapperSyncer.context,
@ -353,7 +355,7 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
return err
}
logger.Log.Debugf("Successfully reset tapper daemon set")
log.Printf("Successfully reset tapper daemon set")
}
tapperSyncer.tappedNodes = nodesToTap

0
shared/kubernetes/podWatchHelper.go → kubernetes/podWatchHelper.go
View File

45
shared/kubernetes/provider.go → kubernetes/provider.go
View File

@ -7,15 +7,16 @@ import (
"errors"
"fmt"
"io"
"log"
"net/url"
"path/filepath"
"regexp"
"strconv"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/shared/semver"
"github.com/kubeshark/kubeshark/semver"
"github.com/kubeshark/kubeshark/utils"
"github.com/kubeshark/worker/api"
"github.com/kubeshark/worker/models"
"github.com/op/go-logging"
auth "k8s.io/api/authorization/v1"
core "k8s.io/api/core/v1"
@ -77,7 +78,7 @@ func NewProvider(kubeConfigPath string, contextName string) (*Provider, error) {
"you can set alternative kube config file path by adding the kube-config-path field to the kubeshark config file, err: %w", kubeConfigPath, err)
}
logger.Log.Debugf("K8s client config, host: %s, api path: %s, user agent: %s", restClientConfig.Host, restClientConfig.APIPath, restClientConfig.UserAgent)
log.Printf("K8s client config, host: %s, api path: %s, user agent: %s", restClientConfig.Host, restClientConfig.APIPath, restClientConfig.UserAgent)
return &Provider{
clientSet: clientSet,
@ -178,7 +179,7 @@ type ApiServerOptions struct {
ServiceAccountName string
IsNamespaceRestricted bool
MaxEntriesDBSizeBytes int64
Resources shared.Resources
Resources models.Resources
ImagePullPolicy core.PullPolicy
LogLevel logging.Level
Profiler bool
@ -220,7 +221,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
volumeMounts := []core.VolumeMount{
{
Name: ConfigMapName,
MountPath: shared.ConfigDirPath,
MountPath: models.ConfigDirPath,
},
}
volumes := []core.Volume{
@ -243,7 +244,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
})
volumeMounts = append(volumeMounts, core.VolumeMount{
Name: volumeClaimName,
MountPath: shared.DataDirPath,
MountPath: models.DataDirPath,
})
}
@ -256,7 +257,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
Command: command,
Env: []core.EnvVar{
{
Name: shared.LogLevelEnvVar,
Name: utils.LogLevelEnvVar,
Value: opts.LogLevel.String(),
},
},
@ -280,7 +281,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
FailureThreshold: 3,
ProbeHandler: core.ProbeHandler{
TCPSocket: &core.TCPSocketAction{
Port: intstr.Parse(shared.BaseninePort),
Port: intstr.Parse(utils.BaseninePort),
},
},
PeriodSeconds: 1,
@ -298,8 +299,8 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
},
},
Command: []string{"basenine"},
Args: []string{"-addr", "0.0.0.0", "-port", shared.BaseninePort, "-persistent"},
WorkingDir: shared.DataDirPath,
Args: []string{"-addr", "0.0.0.0", "-port", utils.BaseninePort, "-persistent"},
WorkingDir: models.DataDirPath,
},
}
@ -452,7 +453,7 @@ func (provider *Provider) BuildFrontPod(opts *ApiServerOptions, mountVolumeClaim
},
Command: []string{"nginx"},
Args: []string{"-g", "daemon off;"},
WorkingDir: shared.DataDirPath,
WorkingDir: models.DataDirPath,
},
}
@ -783,7 +784,7 @@ func (provider *Provider) handleRemovalError(err error) error {
func (provider *Provider) CreateConfigMap(ctx context.Context, namespace string, configMapName string, serializedKubesharkConfig string) error {
configMapData := make(map[string]string)
configMapData[shared.ConfigFileName] = serializedKubesharkConfig
configMapData[models.ConfigFileName] = serializedKubesharkConfig
configMap := &core.ConfigMap{
TypeMeta: metav1.TypeMeta{
@ -805,8 +806,8 @@ func (provider *Provider) CreateConfigMap(ctx context.Context, namespace string,
return nil
}
func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, namespace string, daemonSetName string, podImage string, tapperPodName string, apiServerPodIp string, nodeNames []string, serviceAccountName string, resources shared.Resources, imagePullPolicy core.PullPolicy, kubesharkApiFilteringOptions api.TrafficFilteringOptions, logLevel logging.Level, serviceMesh bool, tls bool, maxLiveStreams int) error {
logger.Log.Debugf("Applying %d tapper daemon sets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeNames), namespace, daemonSetName, podImage, tapperPodName)
func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, namespace string, daemonSetName string, podImage string, tapperPodName string, apiServerPodIp string, nodeNames []string, serviceAccountName string, resources models.Resources, imagePullPolicy core.PullPolicy, kubesharkApiFilteringOptions api.TrafficFilteringOptions, logLevel logging.Level, serviceMesh bool, tls bool, maxLiveStreams int) error {
log.Printf("Applying %d tapper daemon sets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeNames), namespace, daemonSetName, podImage, tapperPodName)
if len(nodeNames) == 0 {
return fmt.Errorf("daemon set %s must tap at least 1 pod", daemonSetName)
@ -863,12 +864,12 @@ func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, nam
agentContainer.WithCommand(kubesharkCmd...)
agentContainer.WithEnv(
applyconfcore.EnvVar().WithName(shared.LogLevelEnvVar).WithValue(logLevel.String()),
applyconfcore.EnvVar().WithName(shared.HostModeEnvVar).WithValue("1"),
applyconfcore.EnvVar().WithName(shared.KubesharkFilteringOptionsEnvVar).WithValue(string(kubesharkApiFilteringOptionsJsonStr)),
applyconfcore.EnvVar().WithName(utils.LogLevelEnvVar).WithValue(logLevel.String()),
applyconfcore.EnvVar().WithName(utils.HostModeEnvVar).WithValue("1"),
applyconfcore.EnvVar().WithName(utils.KubesharkFilteringOptionsEnvVar).WithValue(string(kubesharkApiFilteringOptionsJsonStr)),
)
agentContainer.WithEnv(
applyconfcore.EnvVar().WithName(shared.NodeNameEnvVar).WithValueFrom(
applyconfcore.EnvVar().WithName(utils.NodeNameEnvVar).WithValueFrom(
applyconfcore.EnvVarSource().WithFieldRef(
applyconfcore.ObjectFieldSelector().WithAPIVersion("v1").WithFieldPath("spec.nodeName"),
),
@ -1158,7 +1159,7 @@ func (provider *Provider) ListManagedRoleBindings(ctx context.Context, namespace
func (provider *Provider) ValidateNotProxy() error {
kubernetesUrl, err := url.Parse(provider.clientConfig.Host)
if err != nil {
logger.Log.Debugf("ValidateNotProxy - error while parsing kubernetes host, err: %v", err)
log.Printf("ValidateNotProxy - error while parsing kubernetes host, err: %v", err)
return nil
}
@ -1183,7 +1184,7 @@ func (provider *Provider) ValidateNotProxy() error {
func (provider *Provider) GetKubernetesVersion() (*semver.SemVersion, error) {
serverVersion, err := provider.clientSet.ServerVersion()
if err != nil {
logger.Log.Debugf("error while getting kubernetes server version, err: %v", err)
log.Printf("error while getting kubernetes server version, err: %v", err)
return nil, err
}
@ -1210,7 +1211,7 @@ func ValidateKubernetesVersion(serverVersionSemVer *semver.SemVersion) error {
}
func loadKubernetesConfiguration(kubeConfigPath string, context string) clientcmd.ClientConfig {
logger.Log.Debugf("Using kube config %s", kubeConfigPath)
log.Printf("Using kube config %s", kubeConfigPath)
configPathList := filepath.SplitList(kubeConfigPath)
configLoadingRules := &clientcmd.ClientConfigLoadingRules{}
if len(configPathList) <= 1 {

14
shared/kubernetes/proxy.go → kubernetes/proxy.go
View File

@ -4,6 +4,7 @@ import (
"bytes"
"context"
"fmt"
"log"
"net"
"net/http"
"net/url"
@ -15,7 +16,6 @@ import (
"k8s.io/client-go/tools/portforward"
"k8s.io/client-go/transport/spdy"
"github.com/kubeshark/kubeshark/logger"
"k8s.io/kubectl/pkg/proxy"
)
@ -23,7 +23,7 @@ const k8sProxyApiPrefix = "/"
const kubesharkServicePort = 80
func StartProxy(kubernetesProvider *Provider, proxyHost string, srcPort uint16, dstPort uint16, kubesharkNamespace string, kubesharkServiceName string, cancel context.CancelFunc) (*http.Server, error) {
logger.Log.Infof("Starting proxy - namespace: [%v], service name: [%s], port: [%d:%d]\n", kubesharkNamespace, kubesharkServiceName, srcPort, dstPort)
log.Printf("Starting proxy - namespace: [%v], service name: [%s], port: [%d:%d]\n", kubesharkNamespace, kubesharkServiceName, srcPort, dstPort)
filter := &proxy.FilterServer{
AcceptPaths: proxy.MakeRegexpArrayOrDie(proxy.DefaultPathAcceptRE),
RejectPaths: proxy.MakeRegexpArrayOrDie(proxy.DefaultPathRejectRE),
@ -50,7 +50,7 @@ func StartProxy(kubernetesProvider *Provider, proxyHost string, srcPort uint16,
go func() {
if err := server.Serve(l); err != nil && err != http.ErrServerClosed {
logger.Log.Errorf("Error creating proxy, %v", err)
log.Printf("Error creating proxy, %v", err)
cancel()
}
}()
@ -105,7 +105,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
podName := pods[0].Name
logger.Log.Debugf("Starting proxy using port-forward method. namespace: [%v], pod name: [%s], %d:%d", namespace, podName, srcPort, dstPort)
log.Printf("Starting proxy using port-forward method. namespace: [%v], pod name: [%s], %d:%d", namespace, podName, srcPort, dstPort)
dialer, err := getHttpDialer(kubernetesProvider, namespace, podName)
if err != nil {
@ -122,7 +122,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
go func() {
if err = forwarder.ForwardPorts(); err != nil {
logger.Log.Errorf("kubernetes port-forwarding error: %v", err)
log.Printf("kubernetes port-forwarding error: %v", err)
cancel()
}
}()
@ -133,7 +133,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
func getHttpDialer(kubernetesProvider *Provider, namespace string, podName string) (httpstream.Dialer, error) {
roundTripper, upgrader, err := spdy.RoundTripperFor(&kubernetesProvider.clientConfig)
if err != nil {
logger.Log.Errorf("Error creating http dialer")
log.Printf("Error creating http dialer")
return nil, err
}
@ -144,7 +144,7 @@ func getHttpDialer(kubernetesProvider *Provider, namespace string, podName strin
path := fmt.Sprintf("%s/api/v1/namespaces/%s/pods/%s/portforward", clientConfigHostUrl.Path, namespace, podName)
serverURL := url.URL{Scheme: "https", Path: path, Host: clientConfigHostUrl.Host}
logger.Log.Debugf("Http dialer url %v", serverURL)
log.Printf("Http dialer url %v", serverURL)
return spdy.NewDialer(upgrader, &http.Client{Transport: roundTripper}, http.MethodPost, &serverURL), nil
}

12
shared/kubernetes/utils.go → kubernetes/utils.go
View File

@ -3,13 +3,13 @@ package kubernetes
import (
"regexp"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/worker/models"
core "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func GetNodeHostToTappedPodsMap(tappedPods []core.Pod) shared.NodeToPodsMap {
nodeToTappedPodMap := make(shared.NodeToPodsMap)
func GetNodeHostToTappedPodsMap(tappedPods []core.Pod) models.NodeToPodsMap {
nodeToTappedPodMap := make(models.NodeToPodsMap)
for _, pod := range tappedPods {
minimizedPod := getMinimizedPod(pod)
@ -86,10 +86,10 @@ func getMissingPods(pods1 []core.Pod, pods2 []core.Pod) []core.Pod {
return missingPods
}
func GetPodInfosForPods(pods []core.Pod) []*shared.PodInfo {
podInfos := make([]*shared.PodInfo, 0)
func GetPodInfosForPods(pods []core.Pod) []*models.PodInfo {
podInfos := make([]*models.PodInfo, 0)
for _, pod := range pods {
podInfos = append(podInfos, &shared.PodInfo{Name: pod.Name, Namespace: pod.Namespace, NodeName: pod.Spec.NodeName})
podInfos = append(podInfos, &models.PodInfo{Name: pod.Name, Namespace: pod.Namespace, NodeName: pod.Spec.NodeName})
}
return podInfos
}

8
shared/kubernetes/watch.go → kubernetes/watch.go
View File

@ -4,11 +4,11 @@ import (
"context"
"errors"
"fmt"
"log"
"sync"
"time"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/debounce"
"github.com/kubeshark/kubeshark/debounce"
"k8s.io/apimachinery/pkg/watch"
)
@ -57,9 +57,9 @@ func FilteredWatch(ctx context.Context, watcherCreator WatchCreator, targetNames
} else {
if !watchRestartDebouncer.IsOn() {
if err := watchRestartDebouncer.SetOn(); err != nil {
logger.Log.Error(err)
log.Print(err)
}
logger.Log.Debug("k8s watch channel closed, restarting watcher")
log.Print("k8s watch channel closed, restarting watcher")
time.Sleep(time.Second * 5)
continue
} else {

0
shared/kubernetes/watchEvent.go → kubernetes/watchEvent.go
View File

10
kubeshark.go Normal file
View File

@ -0,0 +1,10 @@
package main
import (
"github.com/kubeshark/kubeshark/cmd"
"github.com/kubeshark/kubeshark/cmd/goUtils"
)
func main() {
goUtils.HandleExcWrapper(cmd.Execute)
}

0
cli/kubeshark/consts.go → kubeshark/consts.go
View File

0
cli/kubeshark/fsUtils/dirUtils.go → kubeshark/fsUtils/dirUtils.go
View File

40
cli/kubeshark/fsUtils/kubesharkLogsUtils.go → kubeshark/fsUtils/kubesharkLogsUtils.go
View File

@ -4,20 +4,14 @@ import (
"archive/zip"
"context"
"fmt"
"log"
"os"
"path"
"regexp"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/kubernetes"
)
func GetLogFilePath() string {
return path.Join(kubeshark.GetKubesharkFolderPath(), "kubeshark_cli.log")
}
func DumpLogs(ctx context.Context, provider *kubernetes.Provider, filePath string) error {
podExactRegex := regexp.MustCompile("^" + kubernetes.KubesharkResourcesPrefix)
pods, err := provider.ListAllPodsMatchingRegex(ctx, podExactRegex, []string{config.Config.KubesharkResourcesNamespace})
@ -41,45 +35,39 @@ func DumpLogs(ctx context.Context, provider *kubernetes.Provider, filePath strin
for _, container := range pod.Spec.Containers {
logs, err := provider.GetPodLogs(ctx, pod.Namespace, pod.Name, container.Name)
if err != nil {
logger.Log.Errorf("Failed to get logs, %v", err)
log.Printf("Failed to get logs, %v", err)
continue
} else {
logger.Log.Debugf("Successfully read log length %d for pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
log.Printf("Successfully read log length %d for pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
}
if err := AddStrToZip(zipWriter, logs, fmt.Sprintf("%s.%s.%s.log", pod.Namespace, pod.Name, container.Name)); err != nil {
logger.Log.Errorf("Failed write logs, %v", err)
log.Printf("Failed write logs, %v", err)
} else {
logger.Log.Debugf("Successfully added log length %d from pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
log.Printf("Successfully added log length %d from pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
}
}
}
events, err := provider.GetNamespaceEvents(ctx, config.Config.KubesharkResourcesNamespace)
if err != nil {
logger.Log.Debugf("Failed to get k8b events, %v", err)
log.Printf("Failed to get k8b events, %v", err)
} else {
logger.Log.Debugf("Successfully read events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
log.Printf("Successfully read events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
}
if err := AddStrToZip(zipWriter, events, fmt.Sprintf("%s_events.log", config.Config.KubesharkResourcesNamespace)); err != nil {
logger.Log.Debugf("Failed write logs, %v", err)
log.Printf("Failed write logs, %v", err)
} else {
logger.Log.Debugf("Successfully added events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
log.Printf("Successfully added events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
}
if err := AddFileToZip(zipWriter, config.Config.ConfigFilePath); err != nil {
logger.Log.Debugf("Failed write file, %v", err)
log.Printf("Failed write file, %v", err)
} else {
logger.Log.Debugf("Successfully added file %s", config.Config.ConfigFilePath)
log.Printf("Successfully added file %s", config.Config.ConfigFilePath)
}
if err := AddFileToZip(zipWriter, GetLogFilePath()); err != nil {
logger.Log.Debugf("Failed write file, %v", err)
} else {
logger.Log.Debugf("Successfully added file %s", GetLogFilePath())
}
logger.Log.Infof("You can find the zip file with all logs in %s", filePath)
log.Printf("You can find the zip file with all logs in %s", filePath)
return nil
}

7
cli/kubeshark/fsUtils/zipUtils.go → kubeshark/fsUtils/zipUtils.go
View File

@ -4,11 +4,10 @@ import (
"archive/zip"
"fmt"
"io"
"log"
"os"
"path/filepath"
"strings"
"github.com/kubeshark/kubeshark/logger"
)
func AddFileToZip(zipWriter *zip.Writer, filename string) error {
@ -84,7 +83,7 @@ func Unzip(reader *zip.Reader, dest string) error {
_ = os.MkdirAll(path, f.Mode())
} else {
_ = os.MkdirAll(filepath.Dir(path), f.Mode())
logger.Log.Infof("writing HAR file [ %v ]", path)
log.Printf("writing HAR file [ %v ]", path)
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
if err != nil {
return err
@ -93,7 +92,7 @@ func Unzip(reader *zip.Reader, dest string) error {
if err := f.Close(); err != nil {
panic(err)
}
logger.Log.Info(" done")
log.Print(" done")
}()
_, err = io.Copy(f, rc)

20
cli/kubeshark/version/versionCheck.go → kubeshark/version/versionCheck.go
View File

@ -4,25 +4,25 @@ import (
"context"
"fmt"
"io"
"log"
"net/http"
"runtime"
"strings"
"time"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/cli/pkg/version"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/kubeshark"
"github.com/kubeshark/kubeshark/pkg/version"
"github.com/google/go-github/v37/github"
)
func CheckNewerVersion(versionChan chan string) {
logger.Log.Debugf("Checking for newer version...")
log.Printf("Checking for newer version...")
start := time.Now()
client := github.NewClient(nil)
latestRelease, _, err := client.Repositories.GetLatestRelease(context.Background(), "kubeshark", "kubeshark")
if err != nil {
logger.Log.Debugf("[ERROR] Failed to get latest release")
log.Printf("[ERROR] Failed to get latest release")
versionChan <- ""
return
}
@ -35,14 +35,14 @@ func CheckNewerVersion(versionChan chan string) {
}
}
if versionFileUrl == "" {
logger.Log.Debugf("[ERROR] Version file not found in the latest release")
log.Printf("[ERROR] Version file not found in the latest release")
versionChan <- ""
return
}
res, err := http.Get(versionFileUrl)
if err != nil {
logger.Log.Debugf("[ERROR] Failed to get the version file %v", err)
log.Printf("[ERROR] Failed to get the version file %v", err)
versionChan <- ""
return
}
@ -50,7 +50,7 @@ func CheckNewerVersion(versionChan chan string) {
data, err := io.ReadAll(res.Body)
res.Body.Close()
if err != nil {
logger.Log.Debugf("[ERROR] Failed to read the version file -> %v", err)
log.Printf("[ERROR] Failed to read the version file -> %v", err)
versionChan <- ""
return
}
@ -59,12 +59,12 @@ func CheckNewerVersion(versionChan chan string) {
greater, err := version.GreaterThen(gitHubVersion, kubeshark.Ver)
if err != nil {
logger.Log.Debugf("[ERROR] Ver version is not valid, github version %v, current version %v", gitHubVersion, kubeshark.Ver)
log.Printf("[ERROR] Ver version is not valid, github version %v, current version %v", gitHubVersion, kubeshark.Ver)
versionChan <- ""
return
}
logger.Log.Debugf("Finished version validation, github version %v, current version %v, took %v", gitHubVersion, kubeshark.Ver, time.Since(start))
log.Printf("Finished version validation, github version %v, current version %v, took %v", gitHubVersion, kubeshark.Ver, time.Since(start))
if greater {
var downloadMessage string

5
logger/go.mod
View File

@ -1,5 +0,0 @@
module github.com/kubeshark/kubeshark/logger
go 1.17
require github.com/op/go-logging v0.0.0-20160315200505-970db520ece7

2
logger/go.sum
View File

@ -1,2 +0,0 @@
github.com/op/go-logging v0.0.0-20160315200505-970db520ece7 h1:lDH9UUVJtmYCjyT0CI4q8xvlXPxeZ0gYCVvWbmPlp88=
github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=

49
logger/logger.go
View File

@ -1,49 +0,0 @@
package logger
import (
"os"
"github.com/op/go-logging"
)
var Log = logging.MustGetLogger("kubeshark")
var format = logging.MustStringFormatter(
`[%{time:2006-01-02T15:04:05.000-0700}] %{level:-5s} ▶ %{message} ▶ [%{pid} %{shortfile} %{shortfunc}]`,
)
func InitLogger(logPath string) {
f, err := os.OpenFile(logPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
Log.Infof("Failed to open kubeshark log file: %v, err %v", logPath, err)
}
fileLog := logging.NewLogBackend(f, "", 0)
consoleLog := logging.NewLogBackend(os.Stderr, "", 0)
backend2Formatter := logging.NewBackendFormatter(fileLog, format)
backend1Leveled := logging.AddModuleLevel(consoleLog)
backend1Leveled.SetLevel(logging.INFO, "")
logging.SetBackend(backend1Leveled, backend2Formatter)
}
func InitLoggerStd(level logging.Level) {
var backends []logging.Backend
stderrBackend := logging.NewLogBackend(os.Stderr, "", 0)
stderrFormater := logging.NewBackendFormatter(stderrBackend, format)
stderrLeveled := logging.AddModuleLevel(stderrFormater)
stderrLeveled.SetLevel(logging.ERROR, "")
backends = append(backends, stderrLeveled)
if level >= logging.WARNING {
stdoutBackend := logging.NewLogBackend(os.Stdout, "", 0)
stdoutFormater := logging.NewBackendFormatter(stdoutBackend, format)
stdoutLeveled := logging.AddModuleLevel(stdoutFormater)
stdoutLeveled.SetLevel(level, "")
backends = append(backends, stdoutLeveled)
}
logging.SetBackend(backends...)
}

0
cli/pkg/version/version.go → pkg/version/version.go
View File

0
cli/pkg/version/version_test.go → pkg/version/version_test.go
View File

25
cli/resources/cleanResources.go → resources/cleanResources.go
View File

@ -3,18 +3,17 @@ package resources
import (
"context"
"fmt"
"log"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/cli/utils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/kubeshark/utils"
"k8s.io/apimachinery/pkg/util/wait"
)
func CleanUpKubesharkResources(ctx context.Context, cancel context.CancelFunc, kubernetesProvider *kubernetes.Provider, isNsRestrictedMode bool, kubesharkResourcesNamespace string) {
logger.Log.Infof("\nRemoving kubeshark resources")
log.Printf("\nRemoving kubeshark resources")
var leftoverResources []string
@ -25,11 +24,11 @@ func CleanUpKubesharkResources(ctx context.Context, cancel context.CancelFunc, k
}
if len(leftoverResources) > 0 {
errMsg := fmt.Sprintf("Failed to remove the following resources, for more info check logs at %s:", fsUtils.GetLogFilePath())
errMsg := "Failed to remove the following resources."
for _, resource := range leftoverResources {
errMsg += "\n- " + resource
}
logger.Log.Errorf(uiUtils.Error, errMsg)
log.Printf(uiUtils.Error, errMsg)
}
}
@ -79,11 +78,11 @@ func waitUntilNamespaceDeleted(ctx context.Context, cancel context.CancelFunc, k
if err := kubernetesProvider.WaitUtilNamespaceDeleted(ctx, kubesharkResourcesNamespace); err != nil {
switch {
case ctx.Err() == context.Canceled:
logger.Log.Debugf("Do nothing. User interrupted the wait")
log.Printf("Do nothing. User interrupted the wait")
case err == wait.ErrWaitTimeout:
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", kubesharkResourcesNamespace))
log.Printf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", kubesharkResourcesNamespace))
default:
logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", kubesharkResourcesNamespace, errormessage.FormatError(err)))
log.Printf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", kubesharkResourcesNamespace, errormessage.FormatError(err)))
}
}
}
@ -151,6 +150,6 @@ func cleanUpRestrictedMode(ctx context.Context, kubernetesProvider *kubernetes.P
}
func handleDeletionError(err error, resourceDesc string, leftoverResources *[]string) {
logger.Log.Debugf("Error removing %s: %v", resourceDesc, errormessage.FormatError(err))
log.Printf("Error removing %s: %v", resourceDesc, errormessage.FormatError(err))
*leftoverResources = append(*leftoverResources, resourceDesc)
}

24
cli/resources/createResources.go → resources/createResources.go
View File

@ -3,19 +3,19 @@ package resources
import (
"context"
"fmt"
"log"
"github.com/kubeshark/kubeshark/cli/config"
"github.com/kubeshark/kubeshark/cli/errormessage"
"github.com/kubeshark/kubeshark/cli/kubeshark"
"github.com/kubeshark/kubeshark/cli/uiUtils"
"github.com/kubeshark/kubeshark/logger"
"github.com/kubeshark/kubeshark/shared"
"github.com/kubeshark/kubeshark/shared/kubernetes"
"github.com/kubeshark/kubeshark/config"
"github.com/kubeshark/kubeshark/errormessage"
"github.com/kubeshark/kubeshark/kubernetes"
"github.com/kubeshark/kubeshark/kubeshark"
"github.com/kubeshark/kubeshark/uiUtils"
"github.com/kubeshark/worker/models"
"github.com/op/go-logging"
core "k8s.io/api/core/v1"
)
func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubernetes.Provider, serializedKubesharkConfig string, isNsRestrictedMode bool, kubesharkResourcesNamespace string, agentImage string, maxEntriesDBSizeBytes int64, apiServerResources shared.Resources, imagePullPolicy core.PullPolicy, logLevel logging.Level, profiler bool) (bool, error) {
func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubernetes.Provider, serializedKubesharkConfig string, isNsRestrictedMode bool, kubesharkResourcesNamespace string, agentImage string, maxEntriesDBSizeBytes int64, apiServerResources models.Resources, imagePullPolicy core.PullPolicy, logLevel logging.Level, profiler bool) (bool, error) {
if !isNsRestrictedMode {
if err := createKubesharkNamespace(ctx, kubernetesProvider, kubesharkResourcesNamespace); err != nil {
return false, err
@ -28,7 +28,7 @@ func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubern
kubesharkServiceAccountExists, err := createRBACIfNecessary(ctx, kubernetesProvider, isNsRestrictedMode, kubesharkResourcesNamespace, []string{"pods", "services", "endpoints"})
if err != nil {
logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Kubeshark will not resolve target IPs to names. error: %v", errormessage.FormatError(err)))
log.Printf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Kubeshark will not resolve target IPs to names. error: %v", errormessage.FormatError(err)))
}
var serviceAccountName string
@ -71,7 +71,7 @@ func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubern
return kubesharkServiceAccountExists, err
}
logger.Log.Debugf("Successfully created service: %s", kubernetes.ApiServerPodName)
log.Printf("Successfully created service: %s", kubernetes.ApiServerPodName)
return kubesharkServiceAccountExists, nil
}
@ -108,7 +108,7 @@ func createKubesharkApiServerPod(ctx context.Context, kubernetesProvider *kubern
if _, err = kubernetesProvider.CreatePod(ctx, opts.Namespace, pod); err != nil {
return err
}
logger.Log.Infof("Successfully created pod: [%s]", pod.Name)
log.Printf("Successfully created pod: [%s]", pod.Name)
return nil
}
@ -120,6 +120,6 @@ func createFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider
if _, err = kubernetesProvider.CreatePod(ctx, opts.Namespace, pod); err != nil {
return err
}
logger.Log.Infof("Successfully created pod: [%s]", pod.Name)
log.Printf("Successfully created pod: [%s]", pod.Name)
return nil
}

0
shared/semver/semver.go → semver/semver.go
View File

2
shared/Makefile
View File

@ -1,2 +0,0 @@
test: ## Run shared tests.
@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

94
shared/go.mod
View File

@ -1,94 +0,0 @@
module github.com/kubeshark/kubeshark/shared
go 1.17
require (
github.com/docker/go-units v0.4.0
github.com/kubeshark/kubeshark/logger v0.0.0
github.com/kubeshark/worker v0.1.1
github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
k8s.io/api v0.23.3
k8s.io/apimachinery v0.23.3
k8s.io/client-go v0.23.3
k8s.io/kubectl v0.23.3
)
require (
cloud.google.com/go/compute v1.2.0 // indirect
github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
github.com/Azure/go-autorest v14.2.0+incompatible // indirect
github.com/Azure/go-autorest/autorest v0.11.24 // indirect
github.com/Azure/go-autorest/autorest/adal v0.9.18 // indirect
github.com/Azure/go-autorest/autorest/date v0.3.0 // indirect
github.com/Azure/go-autorest/logger v0.2.1 // indirect
github.com/Azure/go-autorest/tracing v0.6.0 // indirect
github.com/MakeNowJust/heredoc v1.0.0 // indirect
github.com/PuerkitoBio/purell v1.1.1 // indirect
github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/evanphx/json-patch v5.6.0+incompatible // indirect
github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
github.com/fvbommel/sortorder v1.0.2 // indirect
github.com/go-errors/errors v1.4.2 // indirect
github.com/go-logr/logr v1.2.2 // indirect
github.com/go-openapi/jsonpointer v0.19.5 // indirect
github.com/go-openapi/jsonreference v0.19.6 // indirect
github.com/go-openapi/swag v0.21.1 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang-jwt/jwt/v4 v4.2.0 // indirect
github.com/golang/protobuf v1.5.2 // indirect
github.com/google/btree v1.0.1 // indirect
github.com/google/go-cmp v0.5.7 // indirect
github.com/google/gofuzz v1.2.0 // indirect
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
github.com/google/uuid v1.3.0 // indirect
github.com/googleapis/gnostic v0.5.5 // indirect
github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
github.com/imdario/mergo v0.3.12 // indirect
github.com/inconshreveable/mousetrap v1.0.0 // indirect
github.com/josharian/intern v1.0.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
github.com/mailru/easyjson v0.7.7 // indirect
github.com/mitchellh/go-wordwrap v1.0.1 // indirect
github.com/moby/spdystream v0.2.0 // indirect
github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // 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/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect
github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/russross/blackfriday v1.6.0 // indirect
github.com/spf13/cobra v1.3.0 // indirect
github.com/spf13/pflag v1.0.5 // indirect
github.com/stretchr/testify v1.7.0 // indirect
github.com/xlab/treeprint v1.1.0 // indirect
go.starlark.net v0.0.0-20220203230714-bb14e151c28f // indirect
golang.org/x/crypto v0.0.0-20220208050332-20e1d8d225ab // indirect
golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd // indirect
golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
golang.org/x/sys v0.0.0-20220207234003-57398862261d // indirect
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
golang.org/x/text v0.3.7 // indirect
golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11 // indirect
google.golang.org/appengine v1.6.7 // indirect
google.golang.org/protobuf v1.27.1 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
k8s.io/cli-runtime v0.23.3 // indirect
k8s.io/component-base v0.23.3 // indirect
k8s.io/klog/v2 v2.40.1 // indirect
k8s.io/kube-openapi v0.0.0-20220124234850-424119656bbf // indirect
k8s.io/utils v0.0.0-20220127004650-9b3446523e65 // indirect
sigs.k8s.io/json v0.0.0-20211208200746-9f7c6b3444d2 // indirect
sigs.k8s.io/kustomize/api v0.11.1 // indirect
sigs.k8s.io/kustomize/kyaml v0.13.3 // indirect
sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
sigs.k8s.io/yaml v1.3.0 // indirect
)
replace github.com/kubeshark/kubeshark/logger v0.0.0 => ../logger

1216
shared/go.sum
View File

File diff suppressed because it is too large Load Diff

131
shared/models.go
View File

@ -1,131 +0,0 @@
package shared
import (
"github.com/op/go-logging"
v1 "k8s.io/api/core/v1"
)
type WebSocketMessageType string
const (
WebSocketMessageTypeEntry WebSocketMessageType = "entry"
WebSocketMessageTypeFullEntry WebSocketMessageType = "fullEntry"
WebSocketMessageTypeTappedEntry WebSocketMessageType = "tappedEntry"
WebSocketMessageTypeUpdateStatus WebSocketMessageType = "status"
WebSocketMessageTypeUpdateTappedPods WebSocketMessageType = "tappedPods"
WebSocketMessageTypeToast WebSocketMessageType = "toast"
WebSocketMessageTypeQueryMetadata WebSocketMessageType = "queryMetadata"
WebSocketMessageTypeStartTime WebSocketMessageType = "startTime"
WebSocketMessageTypeTapConfig WebSocketMessageType = "tapConfig"
)
type Resources struct {
CpuLimit string `yaml:"cpu-limit" default:"750m"`
MemoryLimit string `yaml:"memory-limit" default:"1Gi"`
CpuRequests string `yaml:"cpu-requests" default:"50m"`
MemoryRequests string `yaml:"memory-requests" default:"50Mi"`
}
type OASConfig struct {
Enable bool `yaml:"enabled" default:"true"`
MaxExampleLen int `yaml:"max-example-len" default:"10240"`
}
type KubesharkAgentConfig struct {
MaxDBSizeBytes int64 `json:"maxDBSizeBytes"`
InsertionFilter string `json:"insertionFilter"`
AgentImage string `json:"agentImage"`
PullPolicy string `json:"pullPolicy"`
LogLevel logging.Level `json:"logLevel"`
TapperResources Resources `json:"tapperResources"`
KubesharkResourcesNamespace string `json:"kubesharkResourceNamespace"`
AgentDatabasePath string `json:"agentDatabasePath"`
ServiceMap bool `json:"serviceMap"`
OAS OASConfig `json:"oas"`
}
type WebSocketMessageMetadata struct {
MessageType WebSocketMessageType `json:"messageType,omitempty"`
}
type WebSocketStatusMessage struct {
*WebSocketMessageMetadata
TappingStatus []TappedPodStatus `json:"tappingStatus"`
}
type WebSocketTappedPodsMessage struct {
*WebSocketMessageMetadata
NodeToTappedPodMap NodeToPodsMap `json:"nodeToTappedPodMap"`
}
type WebSocketTapConfigMessage struct {
*WebSocketMessageMetadata
TapTargets []v1.Pod `json:"pods"`
}
type NodeToPodsMap map[string][]v1.Pod
func (np NodeToPodsMap) Summary() map[string][]string {
summary := make(map[string][]string)
for node, pods := range np {
for _, pod := range pods {
summary[node] = append(summary[node], pod.Namespace+"/"+pod.Name)
}
}
return summary
}
type TapperStatus struct {
TapperName string `json:"tapperName"`
NodeName string `json:"nodeName"`
Status string `json:"status"`
}
type TappedPodStatus struct {
Name string `json:"name"`
Namespace string `json:"namespace"`
IsTapped bool `json:"isTapped"`
}
type PodInfo struct {
Namespace string `json:"namespace"`
Name string `json:"name"`
NodeName string `json:"nodeName"`
}
type TLSLinkInfo struct {
SourceIP string `json:"sourceIP"`
DestinationAddress string `json:"destinationAddress"`
ResolvedDestinationName string `json:"resolvedDestinationName"`
ResolvedSourceName string `json:"resolvedSourceName"`
}
func CreateWebSocketStatusMessage(tappedPodsStatus []TappedPodStatus) WebSocketStatusMessage {
return WebSocketStatusMessage{
WebSocketMessageMetadata: &WebSocketMessageMetadata{
MessageType: WebSocketMessageTypeUpdateStatus,
},
TappingStatus: tappedPodsStatus,
}
}
func CreateWebSocketTappedPodsMessage(nodeToTappedPodMap NodeToPodsMap) WebSocketTappedPodsMessage {
return WebSocketTappedPodsMessage{
WebSocketMessageMetadata: &WebSocketMessageMetadata{
MessageType: WebSocketMessageTypeUpdateTappedPods,
},
NodeToTappedPodMap: nodeToTappedPodMap,
}
}
type HealthResponse struct {
TappedPods []*PodInfo `json:"tappedPods"`
ConnectedTappersCount int `json:"connectedTappersCount"`
TappersStatus []*TapperStatus `json:"tappersStatus"`
}
type VersionResponse struct {
Ver string `json:"ver"`
}

130
shared/sliceUtils_test.go
View File

@ -1,130 +0,0 @@
package shared_test
import (
"fmt"
"github.com/kubeshark/kubeshark/shared"
"reflect"
"testing"
)
func TestContainsExists(t *testing.T) {
tests := []struct {
Slice []string
ContainsValue string
Expected bool
}{
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apple", Expected: true},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "orange", Expected: true},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "banana", Expected: true},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "grapes", Expected: true},
}
for _, test := range tests {
t.Run(test.ContainsValue, func(t *testing.T) {
actual := shared.Contains(test.Slice, test.ContainsValue)
if actual != test.Expected {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}
func TestContainsNotExists(t *testing.T) {
tests := []struct {
Slice []string
ContainsValue string
Expected bool
}{
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "cat", Expected: false},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "dog", Expected: false},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apples", Expected: false},
{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "rapes", Expected: false},
}
for _, test := range tests {
t.Run(test.ContainsValue, func(t *testing.T) {
actual := shared.Contains(test.Slice, test.ContainsValue)
if actual != test.Expected {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}
func TestContainsEmptySlice(t *testing.T) {
tests := []struct {
Slice []string
ContainsValue string
Expected bool
}{
{Slice: []string{}, ContainsValue: "cat", Expected: false},
{Slice: []string{}, ContainsValue: "dog", Expected: false},
}
for _, test := range tests {
t.Run(test.ContainsValue, func(t *testing.T) {
actual := shared.Contains(test.Slice, test.ContainsValue)
if actual != test.Expected {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}
func TestContainsNilSlice(t *testing.T) {
tests := []struct {
Slice []string
ContainsValue string
Expected bool
}{
{Slice: nil, ContainsValue: "cat", Expected: false},
{Slice: nil, ContainsValue: "dog", Expected: false},
}
for _, test := range tests {
t.Run(test.ContainsValue, func(t *testing.T) {
actual := shared.Contains(test.Slice, test.ContainsValue)
if actual != test.Expected {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}
func TestUniqueNoDuplicateValues(t *testing.T) {
tests := []struct {
Slice []string
Expected []string
}{
{Slice: []string{"apple", "orange", "banana", "grapes"}, Expected: []string{"apple", "orange", "banana", "grapes"}},
{Slice: []string{"dog", "cat", "mouse"}, Expected: []string{"dog", "cat", "mouse"}},
}
for index, test := range tests {
t.Run(fmt.Sprintf("%v", index), func(t *testing.T) {
actual := shared.Unique(test.Slice)
if !reflect.DeepEqual(test.Expected, actual) {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}
func TestUniqueDuplicateValues(t *testing.T) {
tests := []struct {
Slice []string
Expected []string
}{
{Slice: []string{"apple", "apple", "orange", "orange", "banana", "banana", "grapes", "grapes"}, Expected: []string{"apple", "orange", "banana", "grapes"}},
{Slice: []string{"dog", "cat", "cat", "mouse"}, Expected: []string{"dog", "cat", "mouse"}},
}
for index, test := range tests {
t.Run(fmt.Sprintf("%v", index), func(t *testing.T) {
actual := shared.Unique(test.Slice)
if !reflect.DeepEqual(test.Expected, actual) {
t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
}
})
}
}

0
cli/uiUtils/colors.go → uiUtils/colors.go
View File

5
cli/uiUtils/openBrowser.go → uiUtils/openBrowser.go
View File

@ -2,10 +2,9 @@ package uiUtils
import (
"fmt"
"log"
"os/exec"
"runtime"
"github.com/kubeshark/kubeshark/logger"
)
func OpenBrowser(url string) {
@ -23,6 +22,6 @@ func OpenBrowser(url string) {
}
if err != nil {
logger.Log.Errorf("error while opening browser, %v", err)
log.Printf("error while opening browser, %v", err)
}
}

0
cli/uiUtils/prettyString.go → uiUtils/prettyString.go
View File

0
shared/units/human_data_sizes.go → units/human_data_sizes.go
View File

13
shared/consts.go → utils/consts.go
View File

@ -1,15 +1,10 @@
package shared
package utils
const (
KubesharkFilteringOptionsEnvVar = "SENSITIVE_DATA_FILTERING_OPTIONS"
KubesharkAgentImageRepo = "docker.io/kubeshark/hub"
LogLevelEnvVar = "LOG_LEVEL"
BaseninePort = "9099"
HostModeEnvVar = "HOST_MODE"
NodeNameEnvVar = "NODE_NAME"
ConfigDirPath = "/app/config/"
DataDirPath = "/app/data/"
ConfigFileName = "kubeshark-config.json"
LogLevelEnvVar = "LOG_LEVEL"
KubesharkAgentImageRepo = "docker.io/kubeshark/hub"
BasenineHost = "127.0.0.1"
BaseninePort = "9099"
BasenineReconnectInterval = 3
)

0
cli/utils/httpUtils.go → utils/httpUtils.go
View File

2
shared/sliceUtils.go → utils/sliceUtils.go
View File

@ -1,4 +1,4 @@
package shared
package utils
func Contains(slice []string, containsValue string) bool {
for _, sliceValue := range slice {

9
cli/utils/waitUtils.go → utils/waitUtils.go
View File

@ -2,25 +2,24 @@ package utils
import (
"context"
"log"
"os"
"os/signal"
"syscall"
"github.com/kubeshark/kubeshark/logger"
)
func WaitForFinish(ctx context.Context, cancel context.CancelFunc) {
logger.Log.Debugf("waiting for finish...")
log.Printf("waiting for finish...")
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
// block until ctx cancel is called or termination signal is received
select {
case <-ctx.Done():
logger.Log.Debugf("ctx done")
log.Printf("ctx done")
break
case <-sigChan:
logger.Log.Debugf("Got termination signal, canceling execution...")
log.Printf("Got termination signal, canceling execution...")
cancel()
}
}