diff --git a/cli/cmd/config.go b/cli/cmd/config.go index 66d4485d8..6fc666fb5 100644 --- a/cli/cmd/config.go +++ b/cli/cmd/config.go @@ -3,7 +3,8 @@ package cmd import ( "fmt" "github.com/spf13/cobra" - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/logger" "github.com/up9inc/mizu/cli/uiUtils" "io/ioutil" ) @@ -14,20 +15,20 @@ var configCmd = &cobra.Command{ Use: "config", Short: "Generate config with default values", RunE: func(cmd *cobra.Command, args []string) error { - template, err := mizu.GetConfigWithDefaults() + template, err := config.GetConfigWithDefaults() if err != nil { - mizu.Log.Errorf("Failed generating config with defaults %v", err) + logger.Log.Errorf("Failed generating config with defaults %v", err) return nil } if regenerateFile { data := []byte(template) - if err := ioutil.WriteFile(mizu.GetConfigFilePath(), data, 0644); err != nil { - mizu.Log.Errorf("Failed writing config %v", err) + if err := ioutil.WriteFile(config.GetConfigFilePath(), data, 0644); err != nil { + logger.Log.Errorf("Failed writing config %v", err) return nil } - mizu.Log.Infof(fmt.Sprintf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, mizu.GetConfigFilePath()))) + logger.Log.Infof(fmt.Sprintf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, config.GetConfigFilePath()))) } else { - mizu.Log.Debugf("Writing template config.\n%v", template) + logger.Log.Debugf("Writing template config.\n%v", template) fmt.Printf("%v", template) } return nil @@ -36,5 +37,5 @@ var configCmd = &cobra.Command{ func init() { rootCmd.AddCommand(configCmd) - configCmd.Flags().BoolVarP(®enerateFile, "regenerate", "r", false, fmt.Sprintf("Regenerate the config file with default values %s", mizu.GetConfigFilePath())) + configCmd.Flags().BoolVarP(®enerateFile, "regenerate", "r", false, fmt.Sprintf("Regenerate the config file with default values %s", config.GetConfigFilePath())) } diff --git a/cli/cmd/fetch.go b/cli/cmd/fetch.go index 3b9b4cc09..f26f43c44 100644 --- a/cli/cmd/fetch.go +++ b/cli/cmd/fetch.go @@ -3,16 +3,18 @@ package cmd import ( "github.com/creasty/defaults" "github.com/spf13/cobra" - "github.com/up9inc/mizu/cli/mizu" - "github.com/up9inc/mizu/cli/mizu/configStructs" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/mizu/version" + "github.com/up9inc/mizu/cli/telemetry" ) var fetchCmd = &cobra.Command{ Use: "fetch", Short: "Download recorded traffic to files", RunE: func(cmd *cobra.Command, args []string) error { - go mizu.ReportRun("fetch", mizu.Config.Fetch) - if isCompatible, err := mizu.CheckVersionCompatibility(mizu.Config.Fetch.GuiPort); err != nil { + go telemetry.ReportRun("fetch", config.Config.Fetch) + if isCompatible, err := version.CheckVersionCompatibility(config.Config.Fetch.GuiPort); err != nil { return err } else if !isCompatible { return nil diff --git a/cli/cmd/fetchRunner.go b/cli/cmd/fetchRunner.go index 9c372a632..b0c76020e 100644 --- a/cli/cmd/fetchRunner.go +++ b/cli/cmd/fetchRunner.go @@ -4,8 +4,9 @@ import ( "archive/zip" "bytes" "fmt" + "github.com/up9inc/mizu/cli/config" "github.com/up9inc/mizu/cli/kubernetes" - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/logger" "io" "io/ioutil" "log" @@ -16,8 +17,8 @@ import ( ) func RunMizuFetch() { - mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.Fetch.GuiPort) - resp, err := http.Get(fmt.Sprintf("http://%s/api/har?from=%v&to=%v", mizuProxiedUrl, mizu.Config.Fetch.FromTimestamp, mizu.Config.Fetch.ToTimestamp)) + mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.Fetch.GuiPort) + resp, err := http.Get(fmt.Sprintf("http://%s/api/har?from=%v&to=%v", mizuProxiedUrl, config.Config.Fetch.FromTimestamp, config.Config.Fetch.ToTimestamp)) if err != nil { log.Fatal(err) } @@ -34,7 +35,7 @@ func RunMizuFetch() { log.Fatal(err) } - _ = Unzip(zipReader, mizu.Config.Fetch.Directory) + _ = Unzip(zipReader, config.Config.Fetch.Directory) } func Unzip(reader *zip.Reader, dest string) error { @@ -64,7 +65,7 @@ func Unzip(reader *zip.Reader, dest string) error { _ = os.MkdirAll(path, f.Mode()) } else { _ = os.MkdirAll(filepath.Dir(path), f.Mode()) - mizu.Log.Infof("writing HAR file [ %v ]", path) + logger.Log.Infof("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 @@ -73,7 +74,7 @@ func Unzip(reader *zip.Reader, dest string) error { if err := f.Close(); err != nil { panic(err) } - mizu.Log.Info(" done") + logger.Log.Info(" done") }() _, err = io.Copy(f, rc) diff --git a/cli/cmd/logs.go b/cli/cmd/logs.go index ec639fc7e..8f7a2f42e 100644 --- a/cli/cmd/logs.go +++ b/cli/cmd/logs.go @@ -3,9 +3,10 @@ package cmd import ( "context" "github.com/spf13/cobra" - "github.com/up9inc/mizu/cli/fsUtils" + "github.com/up9inc/mizu/cli/config" "github.com/up9inc/mizu/cli/kubernetes" - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu/fsUtils" "os" "path" ) @@ -16,7 +17,7 @@ var logsCmd = &cobra.Command{ Use: "logs", Short: "Create a zip file with logs for Github issue or troubleshoot", RunE: func(cmd *cobra.Command, args []string) error { - kubernetesProvider, err := kubernetes.NewProvider(mizu.Config.View.KubeConfigPath) + kubernetesProvider, err := kubernetes.NewProvider(config.Config.View.KubeConfigPath) if err != nil { return nil } @@ -25,15 +26,15 @@ var logsCmd = &cobra.Command{ if filePath == "" { pwd, err := os.Getwd() if err != nil { - mizu.Log.Errorf("Failed to get PWD, %v (try using `mizu logs -f )`", err) + logger.Log.Errorf("Failed to get PWD, %v (try using `mizu logs -f )`", err) return nil } filePath = path.Join(pwd, "mizu_logs.zip") } - mizu.Log.Debugf("Using file path %s", filePath) + logger.Log.Debugf("Using file path %s", filePath) if err := fsUtils.DumpLogs(kubernetesProvider, ctx, filePath); err != nil { - mizu.Log.Errorf("Failed dump logs %v", err) + logger.Log.Errorf("Failed dump logs %v", err) } return nil diff --git a/cli/cmd/root.go b/cli/cmd/root.go index 84f6dde3b..70abf7bd5 100644 --- a/cli/cmd/root.go +++ b/cli/cmd/root.go @@ -3,8 +3,10 @@ package cmd import ( "fmt" "github.com/spf13/cobra" - "github.com/up9inc/mizu/cli/fsUtils" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/logger" "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/mizu/fsUtils" ) var rootCmd = &cobra.Command{ @@ -14,11 +16,11 @@ var rootCmd = &cobra.Command{ Further info is available at https://github.com/up9inc/mizu`, PersistentPreRunE: func(cmd *cobra.Command, args []string) error { if err := fsUtils.EnsureDir(mizu.GetMizuFolderPath()); err != nil { - mizu.Log.Errorf("Failed to use mizu folder, %v", err) + logger.Log.Errorf("Failed to use mizu folder, %v", err) } - mizu.InitLogger() - if err := mizu.InitConfig(cmd); err != nil { - mizu.Log.Fatal(err) + logger.InitLogger() + if err := config.InitConfig(cmd); err != nil { + logger.Log.Fatal(err) } return nil @@ -26,7 +28,7 @@ Further info is available at https://github.com/up9inc/mizu`, } func init() { - rootCmd.PersistentFlags().StringSlice(mizu.SetCommandName, []string{}, fmt.Sprintf("Override values using --%s", mizu.SetCommandName)) + rootCmd.PersistentFlags().StringSlice(config.SetCommandName, []string{}, fmt.Sprintf("Override values using --%s", config.SetCommandName)) } // Execute adds all child commands to the root command and sets flags appropriately. diff --git a/cli/cmd/tap.go b/cli/cmd/tap.go index a213d7f2e..abb10e801 100644 --- a/cli/cmd/tap.go +++ b/cli/cmd/tap.go @@ -2,13 +2,15 @@ package cmd import ( "errors" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/telemetry" "os" "github.com/creasty/defaults" "github.com/spf13/cobra" "github.com/up9inc/mizu/cli/errormessage" - "github.com/up9inc/mizu/cli/mizu" - "github.com/up9inc/mizu/cli/mizu/configStructs" "github.com/up9inc/mizu/cli/uiUtils" ) @@ -20,31 +22,31 @@ var tapCmd = &cobra.Command{ Long: `Record the ingoing traffic of a kubernetes pod. Supported protocols are HTTP and gRPC.`, RunE: func(cmd *cobra.Command, args []string) error { - go mizu.ReportRun("tap", mizu.Config.Tap) + go telemetry.ReportRun("tap", config.Config.Tap) RunMizuTap() return nil }, PreRunE: func(cmd *cobra.Command, args []string) error { if len(args) == 1 { - mizu.Config.Tap.PodRegexStr = args[0] + config.Config.Tap.PodRegexStr = args[0] } else if len(args) > 1 { return errors.New("unexpected number of arguments") } - if err := mizu.Config.Validate(); err != nil { + if err := config.Config.Validate(); err != nil { return errormessage.FormatError(err) } - if err := mizu.Config.Tap.Validate(); err != nil { + if err := config.Config.Tap.Validate(); err != nil { return errormessage.FormatError(err) } - mizu.Log.Infof("Mizu will store up to %s of traffic, old traffic will be cleared once the limit is reached.", mizu.Config.Tap.HumanMaxEntriesDBSize) + logger.Log.Infof("Mizu will store up to %s of traffic, old traffic will be cleared once the limit is reached.", config.Config.Tap.HumanMaxEntriesDBSize) - if mizu.Config.Tap.Analysis { - mizu.Log.Infof(analysisMessageToConfirm) + if config.Config.Tap.Analysis { + logger.Log.Infof(analysisMessageToConfirm) if !uiUtils.AskForConfirmation("Would you like to proceed [Y/n]: ") { - mizu.Log.Infof("You can always run mizu without analysis, aborting") + logger.Log.Infof("You can always run mizu without analysis, aborting") os.Exit(0) } } diff --git a/cli/cmd/tapRunner.go b/cli/cmd/tapRunner.go index 43756cf59..be0aac841 100644 --- a/cli/cmd/tapRunner.go +++ b/cli/cmd/tapRunner.go @@ -5,9 +5,12 @@ import ( "context" "encoding/json" "fmt" - "github.com/up9inc/mizu/cli/fsUtils" - "github.com/up9inc/mizu/cli/goUtils" - "github.com/up9inc/mizu/cli/mizu/configStructs" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu/fsUtils" + "github.com/up9inc/mizu/cli/mizu/goUtils" + "github.com/up9inc/mizu/cli/mizu/version" "net/http" "net/url" "os" @@ -46,21 +49,21 @@ var state tapState func RunMizuTap() { mizuApiFilteringOptions, err := getMizuApiFilteringOptions() if err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error parsing regex-masking: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error parsing regex-masking: %v", errormessage.FormatError(err))) return } var mizuValidationRules string - if mizu.Config.Tap.EnforcePolicyFile != "" { - mizuValidationRules, err = readValidationRules(mizu.Config.Tap.EnforcePolicyFile) + if config.Config.Tap.EnforcePolicyFile != "" { + mizuValidationRules, err = readValidationRules(config.Config.Tap.EnforcePolicyFile) if err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error reading policy file: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error reading policy file: %v", errormessage.FormatError(err))) return } } - kubernetesProvider, err := kubernetes.NewProvider(mizu.Config.KubeConfigPath) + kubernetesProvider, err := kubernetes.NewProvider(config.Config.KubeConfigPath) if err != nil { - mizu.Log.Error(err) + logger.Log.Error(err) return } @@ -75,11 +78,11 @@ func RunMizuTap() { } else { namespacesStr = "all namespaces" } - mizu.CheckNewerVersion() - mizu.Log.Infof("Tapping pods in %s", namespacesStr) + version.CheckNewerVersion() + logger.Log.Infof("Tapping pods in %s", namespacesStr) if err, _ := updateCurrentlyTappedPods(kubernetesProvider, ctx, targetNamespaces); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error getting pods by regex: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error getting pods by regex: %v", errormessage.FormatError(err))) return } @@ -88,10 +91,10 @@ func RunMizuTap() { if !mizu.Contains(targetNamespaces, mizu.K8sAllNamespaces) { suggestionStr = ". Select a different namespace with -n or tap all namespaces with -A" } - mizu.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Did not find any pods matching the regex argument%s", suggestionStr)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Did not find any pods matching the regex argument%s", suggestionStr)) } - if mizu.Config.Tap.DryRun { + if config.Config.Tap.DryRun { return } @@ -99,7 +102,7 @@ func RunMizuTap() { defer cleanUpMizuResources(kubernetesProvider) if err := createMizuResources(ctx, kubernetesProvider, nodeToTappedPodIPMap, mizuApiFilteringOptions, mizuValidationRules); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err))) return } @@ -120,7 +123,7 @@ func readValidationRules(file string) (string, error) { } func createMizuResources(ctx context.Context, kubernetesProvider *kubernetes.Provider, nodeToTappedPodIPMap map[string][]string, mizuApiFilteringOptions *shared.TrafficFilteringOptions, mizuValidationRules string) error { - if !mizu.Config.IsNsRestrictedMode() { + if !config.Config.IsNsRestrictedMode() { if err := createMizuNamespace(ctx, kubernetesProvider); err != nil { return err } @@ -135,7 +138,7 @@ func createMizuResources(ctx context.Context, kubernetesProvider *kubernetes.Pro } if err := createMizuConfigmap(ctx, kubernetesProvider, mizuValidationRules); err != nil { - mizu.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to create resources required for policy validation. Mizu will not validate policy rules. error: %v\n", errormessage.FormatError(err))) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to create resources required for policy validation. Mizu will not validate policy rules. error: %v\n", errormessage.FormatError(err))) state.doNotRemoveConfigMap = true } else if mizuValidationRules == "" { state.doNotRemoveConfigMap = true @@ -145,12 +148,12 @@ func createMizuResources(ctx context.Context, kubernetesProvider *kubernetes.Pro } func createMizuConfigmap(ctx context.Context, kubernetesProvider *kubernetes.Provider, data string) error { - err := kubernetesProvider.CreateConfigMap(ctx, mizu.Config.MizuResourcesNamespace, mizu.ConfigMapName, data) + err := kubernetesProvider.CreateConfigMap(ctx, config.Config.MizuResourcesNamespace, mizu.ConfigMapName, data) return err } func createMizuNamespace(ctx context.Context, kubernetesProvider *kubernetes.Provider) error { - _, err := kubernetesProvider.CreateNamespace(ctx, mizu.Config.MizuResourcesNamespace) + _, err := kubernetesProvider.CreateNamespace(ctx, config.Config.MizuResourcesNamespace) return err } @@ -159,7 +162,7 @@ func createMizuApiServer(ctx context.Context, kubernetesProvider *kubernetes.Pro state.mizuServiceAccountExists, err = createRBACIfNecessary(ctx, kubernetesProvider) if err != nil { - mizu.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Mizu will not resolve target IPs to names. error: %v", errormessage.FormatError(err))) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Mizu will not resolve target IPs to names. error: %v", errormessage.FormatError(err))) } var serviceAccountName string @@ -170,25 +173,25 @@ func createMizuApiServer(ctx context.Context, kubernetesProvider *kubernetes.Pro } opts := &kubernetes.ApiServerOptions{ - Namespace: mizu.Config.MizuResourcesNamespace, + Namespace: config.Config.MizuResourcesNamespace, PodName: mizu.ApiServerPodName, - PodImage: mizu.Config.AgentImage, + PodImage: config.Config.AgentImage, ServiceAccountName: serviceAccountName, - IsNamespaceRestricted: mizu.Config.IsNsRestrictedMode(), + IsNamespaceRestricted: config.Config.IsNsRestrictedMode(), MizuApiFilteringOptions: mizuApiFilteringOptions, - MaxEntriesDBSizeBytes: mizu.Config.Tap.MaxEntriesDBSizeBytes(), + MaxEntriesDBSizeBytes: config.Config.Tap.MaxEntriesDBSizeBytes(), } _, err = kubernetesProvider.CreateMizuApiServerPod(ctx, opts) if err != nil { return err } - mizu.Log.Debugf("Successfully created API server pod: %s", mizu.ApiServerPodName) + logger.Log.Debugf("Successfully created API server pod: %s", mizu.ApiServerPodName) - state.apiServerService, err = kubernetesProvider.CreateService(ctx, mizu.Config.MizuResourcesNamespace, mizu.ApiServerPodName, mizu.ApiServerPodName) + state.apiServerService, err = kubernetesProvider.CreateService(ctx, config.Config.MizuResourcesNamespace, mizu.ApiServerPodName, mizu.ApiServerPodName) if err != nil { return err } - mizu.Log.Debugf("Successfully created service: %s", mizu.ApiServerPodName) + logger.Log.Debugf("Successfully created service: %s", mizu.ApiServerPodName) return nil } @@ -196,9 +199,9 @@ func createMizuApiServer(ctx context.Context, kubernetesProvider *kubernetes.Pro func getMizuApiFilteringOptions() (*shared.TrafficFilteringOptions, error) { var compiledRegexSlice []*shared.SerializableRegexp - if mizu.Config.Tap.PlainTextFilterRegexes != nil && len(mizu.Config.Tap.PlainTextFilterRegexes) > 0 { + if config.Config.Tap.PlainTextFilterRegexes != nil && len(config.Config.Tap.PlainTextFilterRegexes) > 0 { compiledRegexSlice = make([]*shared.SerializableRegexp, 0) - for _, regexStr := range mizu.Config.Tap.PlainTextFilterRegexes { + for _, regexStr := range config.Config.Tap.PlainTextFilterRegexes { compiledRegex, err := shared.CompileRegexToSerializableRegexp(regexStr) if err != nil { return nil, err @@ -209,8 +212,8 @@ func getMizuApiFilteringOptions() (*shared.TrafficFilteringOptions, error) { return &shared.TrafficFilteringOptions{ PlainTextMaskingRegexes: compiledRegexSlice, - HealthChecksUserAgentHeaders: mizu.Config.Tap.HealthChecksUserAgentHeaders, - DisableRedaction: mizu.Config.Tap.DisableRedaction, + HealthChecksUserAgentHeaders: config.Config.Tap.HealthChecksUserAgentHeaders, + DisableRedaction: config.Config.Tap.DisableRedaction, }, nil } @@ -225,20 +228,20 @@ func updateMizuTappers(ctx context.Context, kubernetesProvider *kubernetes.Provi if err := kubernetesProvider.ApplyMizuTapperDaemonSet( ctx, - mizu.Config.MizuResourcesNamespace, + config.Config.MizuResourcesNamespace, mizu.TapperDaemonSetName, - mizu.Config.AgentImage, + config.Config.AgentImage, mizu.TapperPodName, fmt.Sprintf("%s.%s.svc.cluster.local", state.apiServerService.Name, state.apiServerService.Namespace), nodeToTappedPodIPMap, serviceAccountName, - mizu.Config.Tap.TapOutgoing(), + config.Config.Tap.TapOutgoing(), ); err != nil { return err } - mizu.Log.Debugf("Successfully created %v tappers", len(nodeToTappedPodIPMap)) + logger.Log.Debugf("Successfully created %v tappers", len(nodeToTappedPodIPMap)) } else { - if err := kubernetesProvider.RemoveDaemonSet(ctx, mizu.Config.MizuResourcesNamespace, mizu.TapperDaemonSetName); err != nil { + if err := kubernetesProvider.RemoveDaemonSet(ctx, config.Config.MizuResourcesNamespace, mizu.TapperDaemonSetName); err != nil { return err } } @@ -251,65 +254,65 @@ func cleanUpMizuResources(kubernetesProvider *kubernetes.Provider) { removalCtx, cancel := context.WithTimeout(context.Background(), cleanupTimeout) defer cancel() - if mizu.Config.DumpLogs { + if config.Config.DumpLogs { mizuDir := mizu.GetMizuFolderPath() filePath = path.Join(mizuDir, fmt.Sprintf("mizu_logs_%s.zip", time.Now().Format("2006_01_02__15_04_05"))) if err := fsUtils.DumpLogs(kubernetesProvider, removalCtx, filePath); err != nil { - mizu.Log.Errorf("Failed dump logs %v", err) + logger.Log.Errorf("Failed dump logs %v", err) } } - mizu.Log.Infof("\nRemoving mizu resources\n") + logger.Log.Infof("\nRemoving mizu resources\n") - if !mizu.Config.IsNsRestrictedMode() { - if err := kubernetesProvider.RemoveNamespace(removalCtx, mizu.Config.MizuResourcesNamespace); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Namespace %s: %v", mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if !config.Config.IsNsRestrictedMode() { + if err := kubernetesProvider.RemoveNamespace(removalCtx, config.Config.MizuResourcesNamespace); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Namespace %s: %v", config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) return } } else { - if err := kubernetesProvider.RemovePod(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.ApiServerPodName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Pod %s in namespace %s: %v", mizu.ApiServerPodName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemovePod(removalCtx, config.Config.MizuResourcesNamespace, mizu.ApiServerPodName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Pod %s in namespace %s: %v", mizu.ApiServerPodName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } - if err := kubernetesProvider.RemoveService(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.ApiServerPodName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Service %s in namespace %s: %v", mizu.ApiServerPodName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveService(removalCtx, config.Config.MizuResourcesNamespace, mizu.ApiServerPodName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Service %s in namespace %s: %v", mizu.ApiServerPodName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } - if err := kubernetesProvider.RemoveDaemonSet(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.TapperDaemonSetName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing DaemonSet %s in namespace %s: %v", mizu.TapperDaemonSetName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveDaemonSet(removalCtx, config.Config.MizuResourcesNamespace, mizu.TapperDaemonSetName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing DaemonSet %s in namespace %s: %v", mizu.TapperDaemonSetName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } if !state.doNotRemoveConfigMap { - if err := kubernetesProvider.RemoveConfigMap(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.ConfigMapName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing ConfigMap %s in namespace %s: %v", mizu.ConfigMapName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveConfigMap(removalCtx, config.Config.MizuResourcesNamespace, mizu.ConfigMapName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing ConfigMap %s in namespace %s: %v", mizu.ConfigMapName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } } } if state.mizuServiceAccountExists { - if !mizu.Config.IsNsRestrictedMode() { + if !config.Config.IsNsRestrictedMode() { if err := kubernetesProvider.RemoveNonNamespacedResources(removalCtx, mizu.ClusterRoleName, mizu.ClusterRoleBindingName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing non-namespaced resources: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing non-namespaced resources: %v", errormessage.FormatError(err))) return } } else { - if err := kubernetesProvider.RemoveServicAccount(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.ServiceAccountName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Service Account %s in namespace %s: %v", mizu.ServiceAccountName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveServicAccount(removalCtx, config.Config.MizuResourcesNamespace, mizu.ServiceAccountName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Service Account %s in namespace %s: %v", mizu.ServiceAccountName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) return } - if err := kubernetesProvider.RemoveRole(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.RoleName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Role %s in namespace %s: %v", mizu.RoleName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveRole(removalCtx, config.Config.MizuResourcesNamespace, mizu.RoleName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing Role %s in namespace %s: %v", mizu.RoleName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } - if err := kubernetesProvider.RemoveRoleBinding(removalCtx, mizu.Config.MizuResourcesNamespace, mizu.RoleBindingName); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing RoleBinding %s in namespace %s: %v", mizu.RoleBindingName, mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + if err := kubernetesProvider.RemoveRoleBinding(removalCtx, config.Config.MizuResourcesNamespace, mizu.RoleBindingName); err != nil { + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error removing RoleBinding %s in namespace %s: %v", mizu.RoleBindingName, config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } } } - if !mizu.Config.IsNsRestrictedMode() { + if !config.Config.IsNsRestrictedMode() { waitUntilNamespaceDeleted(removalCtx, cancel, kubernetesProvider) } } @@ -320,20 +323,20 @@ func waitUntilNamespaceDeleted(ctx context.Context, cancel context.CancelFunc, k waitForFinish(ctx, cancel) }() - if err := kubernetesProvider.WaitUtilNamespaceDeleted(ctx, mizu.Config.MizuResourcesNamespace); err != nil { + if err := kubernetesProvider.WaitUtilNamespaceDeleted(ctx, config.Config.MizuResourcesNamespace); err != nil { switch { case ctx.Err() == context.Canceled: // Do nothing. User interrupted the wait. case err == wait.ErrWaitTimeout: - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", mizu.Config.MizuResourcesNamespace)) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", config.Config.MizuResourcesNamespace)) default: - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", mizu.Config.MizuResourcesNamespace, errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", config.Config.MizuResourcesNamespace, errormessage.FormatError(err))) } } } func reportTappedPods() { - mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.Tap.GuiPort) + mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.Tap.GuiPort) tappedPodsUrl := fmt.Sprintf("http://%s/status/tappedPods", mizuProxiedUrl) podInfos := make([]shared.PodInfo, 0) @@ -343,30 +346,30 @@ func reportTappedPods() { tapStatus := shared.TapStatus{Pods: podInfos} if jsonValue, err := json.Marshal(tapStatus); err != nil { - mizu.Log.Debugf("[ERROR] failed Marshal the tapped pods %v", err) + logger.Log.Debugf("[ERROR] failed Marshal the tapped pods %v", err) } else { if response, err := http.Post(tappedPodsUrl, "application/json", bytes.NewBuffer(jsonValue)); err != nil { - mizu.Log.Debugf("[ERROR] failed sending to API server the tapped pods %v", err) + logger.Log.Debugf("[ERROR] failed sending to API server the tapped pods %v", err) } else if response.StatusCode != 200 { - mizu.Log.Debugf("[ERROR] failed sending to API server the tapped pods, response status code %v", response.StatusCode) + logger.Log.Debugf("[ERROR] failed sending to API server the tapped pods, response status code %v", response.StatusCode) } else { - mizu.Log.Debugf("Reported to server API about %d taped pods successfully", len(podInfos)) + logger.Log.Debugf("Reported to server API about %d taped pods successfully", len(podInfos)) } } } func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Provider, targetNamespaces []string, cancel context.CancelFunc) { - added, modified, removed, errorChan := kubernetes.FilteredWatch(ctx, kubernetesProvider, targetNamespaces, mizu.Config.Tap.PodRegex()) + added, modified, removed, errorChan := kubernetes.FilteredWatch(ctx, kubernetesProvider, targetNamespaces, config.Config.Tap.PodRegex()) restartTappers := func() { err, changeFound := updateCurrentlyTappedPods(kubernetesProvider, ctx, targetNamespaces) if err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Failed to update currently tapped pods: %v", err)) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Failed to update currently tapped pods: %v", err)) cancel() } if !changeFound { - mizu.Log.Debugf("Nothing changed update tappers not needed") + logger.Log.Debugf("Nothing changed update tappers not needed") return } @@ -374,11 +377,11 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro nodeToTappedPodIPMap := getNodeHostToTappedPodIpsMap(state.currentlyTappedPods) if err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error building node to ips map: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error building node to ips map: %v", errormessage.FormatError(err))) cancel() } if err := updateMizuTappers(ctx, kubernetesProvider, nodeToTappedPodIPMap); err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error updating daemonset: %v", errormessage.FormatError(err))) + logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error updating daemonset: %v", errormessage.FormatError(err))) cancel() } } @@ -387,13 +390,13 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro for { select { case pod := <-added: - mizu.Log.Debugf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace) + logger.Log.Debugf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace) restartTappersDebouncer.SetOn() case pod := <-removed: - mizu.Log.Debugf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace) + logger.Log.Debugf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace) restartTappersDebouncer.SetOn() case pod := <-modified: - mizu.Log.Debugf("Modified matching pod %s, ns: %s, phase: %s, ip: %s", pod.Name, pod.Namespace, pod.Status.Phase, pod.Status.PodIP) + logger.Log.Debugf("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 @@ -405,13 +408,13 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro } case err := <-errorChan: - mizu.Log.Debugf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err) + logger.Log.Debugf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err) restartTappersDebouncer.Cancel() // TODO: Does this also perform cleanup? cancel() case <-ctx.Done(): - mizu.Log.Debugf("Watching pods loop, context done, stopping `restart tappers debouncer`") + logger.Log.Debugf("Watching pods loop, context done, stopping `restart tappers debouncer`") restartTappersDebouncer.Cancel() return } @@ -420,18 +423,18 @@ func watchPodsForTapping(ctx context.Context, kubernetesProvider *kubernetes.Pro func updateCurrentlyTappedPods(kubernetesProvider *kubernetes.Provider, ctx context.Context, targetNamespaces []string) (error, bool) { changeFound := false - if matchingPods, err := kubernetesProvider.ListAllRunningPodsMatchingRegex(ctx, mizu.Config.Tap.PodRegex(), targetNamespaces); err != nil { + if matchingPods, err := kubernetesProvider.ListAllRunningPodsMatchingRegex(ctx, config.Config.Tap.PodRegex(), targetNamespaces); err != nil { return err, false } else { podsToTap := excludeMizuPods(matchingPods) addedPods, removedPods := getPodArrayDiff(state.currentlyTappedPods, podsToTap) for _, addedPod := range addedPods { changeFound = true - mizu.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", addedPod.Name)) + logger.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", addedPod.Name)) } for _, removedPod := range removedPods { changeFound = true - mizu.Log.Infof(uiUtils.Red, fmt.Sprintf("-%s", removedPod.Name)) + logger.Log.Infof(uiUtils.Red, fmt.Sprintf("-%s", removedPod.Name)) } state.currentlyTappedPods = podsToTap } @@ -479,86 +482,86 @@ func getMissingPods(pods1 []core.Pod, pods2 []core.Pod) []core.Pod { func createProxyToApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provider, cancel context.CancelFunc) { podExactRegex := regexp.MustCompile(fmt.Sprintf("^%s$", mizu.ApiServerPodName)) - added, modified, removed, errorChan := kubernetes.FilteredWatch(ctx, kubernetesProvider, []string{mizu.Config.MizuResourcesNamespace}, podExactRegex) + added, modified, removed, errorChan := kubernetes.FilteredWatch(ctx, kubernetesProvider, []string{config.Config.MizuResourcesNamespace}, podExactRegex) isPodReady := false timeAfter := time.After(25 * time.Second) for { select { case <-ctx.Done(): - mizu.Log.Debugf("Watching API Server pod loop, ctx done") + logger.Log.Debugf("Watching API Server pod loop, ctx done") return case <-added: - mizu.Log.Debugf("Watching API Server pod loop, added") + logger.Log.Debugf("Watching API Server pod loop, added") continue case <-removed: - mizu.Log.Infof("%s removed", mizu.ApiServerPodName) + logger.Log.Infof("%s removed", mizu.ApiServerPodName) cancel() return case modifiedPod := <-modified: if modifiedPod == nil { - mizu.Log.Debugf("Watching API Server pod loop, modifiedPod with nil") + logger.Log.Debugf("Watching API Server pod loop, modifiedPod with nil") continue } - mizu.Log.Debugf("Watching API Server pod loop, modified: %v", modifiedPod.Status.Phase) + logger.Log.Debugf("Watching API Server pod loop, modified: %v", modifiedPod.Status.Phase) if modifiedPod.Status.Phase == core.PodRunning && !isPodReady { isPodReady = true go startProxyReportErrorIfAny(kubernetesProvider, cancel) - mizu.Log.Infof("Mizu is available at http://%s\n", kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.Tap.GuiPort)) + logger.Log.Infof("Mizu is available at http://%s\n", kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.Tap.GuiPort)) time.Sleep(time.Second * 5) // Waiting to be sure the proxy is ready requestForAnalysis() reportTappedPods() } case <-timeAfter: if !isPodReady { - mizu.Log.Errorf(uiUtils.Error, "Mizu API server was not ready in time") + logger.Log.Errorf(uiUtils.Error, "Mizu API server was not ready in time") cancel() } case <-errorChan: - mizu.Log.Debugf("[ERROR] Agent creation, watching %v namespace", mizu.Config.MizuResourcesNamespace) + logger.Log.Debugf("[ERROR] Agent creation, watching %v namespace", config.Config.MizuResourcesNamespace) cancel() } } } func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, cancel context.CancelFunc) { - err := kubernetes.StartProxy(kubernetesProvider, mizu.Config.Tap.GuiPort, mizu.Config.MizuResourcesNamespace, mizu.ApiServerPodName) + err := kubernetes.StartProxy(kubernetesProvider, config.Config.Tap.GuiPort, config.Config.MizuResourcesNamespace, mizu.ApiServerPodName) if err != nil { - mizu.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error occured while running k8s proxy %v\n"+ + logger.Log.Errorf(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() } } func requestForAnalysis() { - if !mizu.Config.Tap.Analysis { + if !config.Config.Tap.Analysis { return } - mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.Tap.GuiPort) - urlPath := fmt.Sprintf("http://%s/api/uploadEntries?dest=%s&interval=%v", mizuProxiedUrl, url.QueryEscape(mizu.Config.Tap.AnalysisDestination), mizu.Config.Tap.SleepIntervalSec) + mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.Tap.GuiPort) + urlPath := fmt.Sprintf("http://%s/api/uploadEntries?dest=%s&interval=%v", mizuProxiedUrl, url.QueryEscape(config.Config.Tap.AnalysisDestination), config.Config.Tap.SleepIntervalSec) u, parseErr := url.ParseRequestURI(urlPath) if parseErr != nil { - mizu.Log.Fatal("Failed parsing the URL (consider changing the analysis dest URL), err: %v", parseErr) + logger.Log.Fatal("Failed parsing the URL (consider changing the analysis dest URL), err: %v", parseErr) } - mizu.Log.Debugf("Sending get request to %v", u.String()) + logger.Log.Debugf("Sending get request to %v", u.String()) if response, requestErr := http.Get(u.String()); requestErr != nil { - mizu.Log.Errorf("Failed to notify agent for analysis, err: %v", requestErr) + logger.Log.Errorf("Failed to notify agent for analysis, err: %v", requestErr) } else if response.StatusCode != 200 { - mizu.Log.Errorf("Failed to notify agent for analysis, status code: %v", response.StatusCode) + logger.Log.Errorf("Failed to notify agent for analysis, status code: %v", response.StatusCode) } else { - mizu.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis") + logger.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis") } } func createRBACIfNecessary(ctx context.Context, kubernetesProvider *kubernetes.Provider) (bool, error) { - if !mizu.Config.IsNsRestrictedMode() { - err := kubernetesProvider.CreateMizuRBAC(ctx, mizu.Config.MizuResourcesNamespace, mizu.ServiceAccountName, mizu.ClusterRoleName, mizu.ClusterRoleBindingName, mizu.RBACVersion) + if !config.Config.IsNsRestrictedMode() { + err := kubernetesProvider.CreateMizuRBAC(ctx, config.Config.MizuResourcesNamespace, mizu.ServiceAccountName, mizu.ClusterRoleName, mizu.ClusterRoleBindingName, mizu.RBACVersion) if err != nil { return false, err } } else { - err := kubernetesProvider.CreateMizuRBACNamespaceRestricted(ctx, mizu.Config.MizuResourcesNamespace, mizu.ServiceAccountName, mizu.RoleName, mizu.RoleBindingName, mizu.RBACVersion) + err := kubernetesProvider.CreateMizuRBACNamespaceRestricted(ctx, config.Config.MizuResourcesNamespace, mizu.ServiceAccountName, mizu.RoleName, mizu.RoleBindingName, mizu.RBACVersion) if err != nil { return false, err } @@ -593,10 +596,10 @@ func waitForFinish(ctx context.Context, cancel context.CancelFunc) { } func getNamespaces(kubernetesProvider *kubernetes.Provider) []string { - if mizu.Config.Tap.AllNamespaces { + if config.Config.Tap.AllNamespaces { return []string{mizu.K8sAllNamespaces} - } else if len(mizu.Config.Tap.Namespaces) > 0 { - return mizu.Config.Tap.Namespaces + } else if len(config.Config.Tap.Namespaces) > 0 { + return config.Config.Tap.Namespaces } else { return []string{kubernetesProvider.CurrentNamespace()} } diff --git a/cli/cmd/version.go b/cli/cmd/version.go index 45fc6dc9a..7d3f9029d 100644 --- a/cli/cmd/version.go +++ b/cli/cmd/version.go @@ -1,27 +1,30 @@ package cmd import ( + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/telemetry" "strconv" "time" "github.com/creasty/defaults" "github.com/spf13/cobra" "github.com/up9inc/mizu/cli/mizu" - "github.com/up9inc/mizu/cli/mizu/configStructs" ) var versionCmd = &cobra.Command{ Use: "version", Short: "Print version info", RunE: func(cmd *cobra.Command, args []string) error { - go mizu.ReportRun("version", mizu.Config.Version) - if mizu.Config.Version.DebugInfo { + go telemetry.ReportRun("version", config.Config.Version) + if config.Config.Version.DebugInfo { timeStampInt, _ := strconv.ParseInt(mizu.BuildTimestamp, 10, 0) - mizu.Log.Infof("Version: %s \nBranch: %s (%s)", mizu.SemVer, mizu.Branch, mizu.GitCommitHash) - mizu.Log.Infof("Build Time: %s (%s)", mizu.BuildTimestamp, time.Unix(timeStampInt, 0)) + logger.Log.Infof("Version: %s \nBranch: %s (%s)", mizu.SemVer, mizu.Branch, mizu.GitCommitHash) + logger.Log.Infof("Build Time: %s (%s)", mizu.BuildTimestamp, time.Unix(timeStampInt, 0)) } else { - mizu.Log.Infof("Version: %s (%s)", mizu.SemVer, mizu.Branch) + logger.Log.Infof("Version: %s (%s)", mizu.SemVer, mizu.Branch) } return nil }, diff --git a/cli/cmd/view.go b/cli/cmd/view.go index 8f9742e2a..39aaf75b4 100644 --- a/cli/cmd/view.go +++ b/cli/cmd/view.go @@ -3,15 +3,16 @@ package cmd import ( "github.com/creasty/defaults" "github.com/spf13/cobra" - "github.com/up9inc/mizu/cli/mizu" - "github.com/up9inc/mizu/cli/mizu/configStructs" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/telemetry" ) var viewCmd = &cobra.Command{ Use: "view", Short: "Open GUI in browser", RunE: func(cmd *cobra.Command, args []string) error { - go mizu.ReportRun("view", mizu.Config.View) + go telemetry.ReportRun("view", config.Config.View) runMizuView() return nil }, diff --git a/cli/cmd/viewRunner.go b/cli/cmd/viewRunner.go index 4b2b11a0d..b85384efd 100644 --- a/cli/cmd/viewRunner.go +++ b/cli/cmd/viewRunner.go @@ -3,46 +3,49 @@ package cmd import ( "context" "fmt" + "github.com/up9inc/mizu/cli/config" "github.com/up9inc/mizu/cli/kubernetes" + "github.com/up9inc/mizu/cli/logger" "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/mizu/version" "net/http" ) func runMizuView() { - kubernetesProvider, err := kubernetes.NewProvider(mizu.Config.View.KubeConfigPath) + kubernetesProvider, err := kubernetes.NewProvider(config.Config.View.KubeConfigPath) if err != nil { - mizu.Log.Error(err) + logger.Log.Error(err) return } ctx, cancel := context.WithCancel(context.Background()) defer cancel() - exists, err := kubernetesProvider.DoesServicesExist(ctx, mizu.Config.MizuResourcesNamespace, mizu.ApiServerPodName) + exists, err := kubernetesProvider.DoesServicesExist(ctx, config.Config.MizuResourcesNamespace, mizu.ApiServerPodName) if err != nil { - mizu.Log.Errorf("Failed to found mizu service %v", err) + logger.Log.Errorf("Failed to found mizu service %v", err) cancel() return } if !exists { - mizu.Log.Infof("%s service not found, you should run `mizu tap` command first", mizu.ApiServerPodName) + logger.Log.Infof("%s service not found, you should run `mizu tap` command first", mizu.ApiServerPodName) cancel() return } - mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.View.GuiPort) + mizuProxiedUrl := kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.View.GuiPort) _, err = http.Get(fmt.Sprintf("http://%s/", mizuProxiedUrl)) if err == nil { - mizu.Log.Infof("Found a running service %s and open port %d", mizu.ApiServerPodName, mizu.Config.View.GuiPort) + logger.Log.Infof("Found a running service %s and open port %d", mizu.ApiServerPodName, config.Config.View.GuiPort) return } - mizu.Log.Debugf("Found service %s, creating k8s proxy", mizu.ApiServerPodName) + logger.Log.Debugf("Found service %s, creating k8s proxy", mizu.ApiServerPodName) go startProxyReportErrorIfAny(kubernetesProvider, cancel) - mizu.Log.Infof("Mizu is available at http://%s\n", kubernetes.GetMizuApiServerProxiedHostAndPath(mizu.Config.View.GuiPort)) - if isCompatible, err := mizu.CheckVersionCompatibility(mizu.Config.View.GuiPort); err != nil { - mizu.Log.Errorf("Failed to check versions compatibility %v", err) + logger.Log.Infof("Mizu is available at http://%s\n", kubernetes.GetMizuApiServerProxiedHostAndPath(config.Config.View.GuiPort)) + if isCompatible, err := version.CheckVersionCompatibility(config.Config.View.GuiPort); err != nil { + logger.Log.Errorf("Failed to check versions compatibility %v", err) cancel() return } else if !isCompatible { diff --git a/cli/mizu/config.go b/cli/config/config.go similarity index 85% rename from cli/mizu/config.go rename to cli/config/config.go index e8cbeea92..43c4749e6 100644 --- a/cli/mizu/config.go +++ b/cli/config/config.go @@ -1,8 +1,11 @@ -package mizu +package config import ( "errors" "fmt" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu" "io/ioutil" "os" "path" @@ -13,7 +16,6 @@ import ( "github.com/creasty/defaults" "github.com/spf13/cobra" "github.com/spf13/pflag" - "github.com/up9inc/mizu/cli/mizu/configStructs" "github.com/up9inc/mizu/cli/uiUtils" "gopkg.in/yaml.v3" ) @@ -62,7 +64,7 @@ func InitConfig(cmd *cobra.Command) error { cmd.Flags().Visit(initFlag) finalConfigPrettified, _ := uiUtils.PrettyJson(Config) - Log.Debugf("Init config finished\n Final config: %v", finalConfigPrettified) + logger.Log.Debugf("Init config finished\n Final config: %v", finalConfigPrettified) return nil } @@ -80,7 +82,7 @@ func GetConfigWithDefaults() (string, error) { } func GetConfigFilePath() string { - return path.Join(GetMizuFolderPath(), "config.yaml") + return path.Join(mizu.GetMizuFolderPath(), "config.yaml") } func mergeConfigFile() error { @@ -97,7 +99,7 @@ func mergeConfigFile() error { if err := yaml.Unmarshal(buf, &Config); err != nil { return err } - Log.Debugf("Found config file, merged to default options") + logger.Log.Debugf("Found config file, merged to default options") return nil } @@ -124,13 +126,13 @@ func mergeSetFlag(configElem reflect.Value, setValues []string) { for _, setValue := range setValues { if !strings.Contains(setValue, Separator) { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument %s (set argument format: =)", setValue)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument %s (set argument format: =)", setValue)) continue } split := strings.SplitN(setValue, Separator, 2) if len(split) != 2 { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument %s (set argument format: =)", setValue)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument %s (set argument format: =)", setValue)) continue } @@ -140,8 +142,8 @@ func mergeSetFlag(configElem reflect.Value, setValues []string) { } for argumentKey, argumentValues := range setMap { - if !Contains(allowedSetFlags, argumentKey) { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument name \"%s\", flag name must be one of the following: \"%s\"", argumentKey, strings.Join(allowedSetFlags, "\", \""))) + if !mizu.Contains(allowedSetFlags, argumentKey) { + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Ignoring set argument name \"%s\", flag name must be one of the following: \"%s\"", argumentKey, strings.Join(allowedSetFlags, "\", \""))) continue } @@ -175,7 +177,7 @@ func mergeFlagValue(currentElem reflect.Value, flagKey string, flagValue string) parsedValue, err := getParsedValue(currentFieldKind, flagValue) if err != nil { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid value %s for flag name %s, expected %s", flagValue, flagKey, currentFieldKind)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid value %s for flag name %s, expected %s", flagValue, flagKey, currentFieldKind)) return } @@ -199,7 +201,7 @@ func mergeFlagValues(currentElem reflect.Value, flagKey string, flagValues []str } if currentFieldKind != reflect.Slice { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid values %s for flag name %s, expected %s", strings.Join(flagValues, ","), flagKey, currentFieldKind)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid values %s for flag name %s, expected %s", strings.Join(flagValues, ","), flagKey, currentFieldKind)) return } @@ -209,7 +211,7 @@ func mergeFlagValues(currentElem reflect.Value, flagKey string, flagValues []str for _, flagValue := range flagValues { parsedValue, err := getParsedValue(flagValueKind, flagValue) if err != nil { - Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid value %s for flag name %s, expected %s", flagValue, flagKey, flagValueKind)) + logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Invalid value %s for flag name %s, expected %s", flagValue, flagKey, flagValueKind)) return } diff --git a/cli/mizu/configStruct.go b/cli/config/configStruct.go similarity index 91% rename from cli/mizu/configStruct.go rename to cli/config/configStruct.go index a4e81bb90..c8947cf52 100644 --- a/cli/mizu/configStruct.go +++ b/cli/config/configStruct.go @@ -1,9 +1,9 @@ -package mizu +package config import ( "fmt" - - "github.com/up9inc/mizu/cli/mizu/configStructs" + "github.com/up9inc/mizu/cli/config/configStructs" + "github.com/up9inc/mizu/cli/mizu" ) const ( @@ -27,7 +27,7 @@ type ConfigStruct struct { } func (config *ConfigStruct) SetDefaults() { - config.AgentImage = fmt.Sprintf("gcr.io/up9-docker-hub/mizu/%s:%s", Branch, SemVer) + config.AgentImage = fmt.Sprintf("gcr.io/up9-docker-hub/mizu/%s:%s", mizu.Branch, mizu.SemVer) } func (config *ConfigStruct) IsNsRestrictedMode() bool { diff --git a/cli/mizu/configStructs/fetchConfig.go b/cli/config/configStructs/fetchConfig.go similarity index 100% rename from cli/mizu/configStructs/fetchConfig.go rename to cli/config/configStructs/fetchConfig.go diff --git a/cli/mizu/configStructs/tapConfig.go b/cli/config/configStructs/tapConfig.go similarity index 100% rename from cli/mizu/configStructs/tapConfig.go rename to cli/config/configStructs/tapConfig.go diff --git a/cli/mizu/configStructs/versionConfig.go b/cli/config/configStructs/versionConfig.go similarity index 100% rename from cli/mizu/configStructs/versionConfig.go rename to cli/config/configStructs/versionConfig.go diff --git a/cli/mizu/configStructs/viewConfig.go b/cli/config/configStructs/viewConfig.go similarity index 100% rename from cli/mizu/configStructs/viewConfig.go rename to cli/config/configStructs/viewConfig.go diff --git a/cli/mizu/config_test.go b/cli/config/config_test.go similarity index 72% rename from cli/mizu/config_test.go rename to cli/config/config_test.go index f1f9edb8a..286d497b4 100644 --- a/cli/mizu/config_test.go +++ b/cli/config/config_test.go @@ -1,7 +1,7 @@ -package mizu_test +package config_test import ( - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/config" "reflect" "strings" "testing" @@ -10,10 +10,10 @@ import ( func TestConfigWriteIgnoresReadonlyFields(t *testing.T) { var readonlyFields []string - configElem := reflect.ValueOf(&mizu.ConfigStruct{}).Elem() + configElem := reflect.ValueOf(&config.ConfigStruct{}).Elem() getFieldsWithReadonlyTag(configElem, &readonlyFields) - config, _ := mizu.GetConfigWithDefaults() + config, _ := config.GetConfigWithDefaults() for _, readonlyField := range readonlyFields { if strings.Contains(config, readonlyField) { t.Errorf("unexpected result - readonly field: %v, config: %v", readonlyField, config) @@ -31,8 +31,8 @@ func getFieldsWithReadonlyTag(currentElem reflect.Value, readonlyFields *[]strin continue } - if _, ok := currentField.Tag.Lookup(mizu.ReadonlyTag); ok { - fieldNameByTag := strings.Split(currentField.Tag.Get(mizu.FieldNameTag), ",")[0] + if _, ok := currentField.Tag.Lookup(config.ReadonlyTag); ok { + fieldNameByTag := strings.Split(currentField.Tag.Get(config.FieldNameTag), ",")[0] *readonlyFields = append(*readonlyFields, fieldNameByTag) } } diff --git a/cli/errormessage/errormessage.go b/cli/errormessage/errormessage.go index 1268f835d..7f9caac0d 100644 --- a/cli/errormessage/errormessage.go +++ b/cli/errormessage/errormessage.go @@ -3,9 +3,7 @@ package errormessage import ( "errors" "fmt" - - "github.com/up9inc/mizu/cli/mizu" - + "github.com/up9inc/mizu/cli/config" regexpsyntax "regexp/syntax" k8serrors "k8s.io/apimachinery/pkg/api/errors" @@ -20,9 +18,9 @@ func FormatError(err error) error { "supply the required permission or control Mizu's access to namespaces by setting %s "+ "in the config file or setting the tapped namespace with --%s %s=", err, - mizu.MizuResourcesNamespaceConfigName, - mizu.SetCommandName, - mizu.MizuResourcesNamespaceConfigName) + config.MizuResourcesNamespaceConfigName, + config.SetCommandName, + config.MizuResourcesNamespaceConfigName) } else if syntaxError, isSyntaxError := asRegexSyntaxError(err); isSyntaxError { errorNew = fmt.Errorf("regex %s is invalid: %w", syntaxError.Expr, err) } else { diff --git a/cli/fsUtils/mizuLogsUtils.go b/cli/fsUtils/mizuLogsUtils.go deleted file mode 100644 index b48cc2aa6..000000000 --- a/cli/fsUtils/mizuLogsUtils.go +++ /dev/null @@ -1,58 +0,0 @@ -package fsUtils - -import ( - "archive/zip" - "context" - "fmt" - "github.com/up9inc/mizu/cli/kubernetes" - "github.com/up9inc/mizu/cli/mizu" - "os" - "regexp" -) - -func DumpLogs(provider *kubernetes.Provider, ctx context.Context, filePath string) error { - podExactRegex := regexp.MustCompile("^" + mizu.MizuResourcesPrefix) - pods, err := provider.ListAllPodsMatchingRegex(ctx, podExactRegex, []string{mizu.Config.MizuResourcesNamespace}) - if err != nil { - return err - } - - if len(pods) == 0 { - return fmt.Errorf("no mizu pods found in namespace %s", mizu.Config.MizuResourcesNamespace) - } - - newZipFile, err := os.Create(filePath) - if err != nil { - return err - } - defer newZipFile.Close() - zipWriter := zip.NewWriter(newZipFile) - defer zipWriter.Close() - - for _, pod := range pods { - logs, err := provider.GetPodLogs(pod.Namespace, pod.Name, ctx) - if err != nil { - mizu.Log.Errorf("Failed to get logs, %v", err) - continue - } else { - mizu.Log.Debugf("Successfully read log length %d for pod: %s.%s", len(logs), pod.Namespace, pod.Name) - } - if err := AddStrToZip(zipWriter, logs, fmt.Sprintf("%s.%s.log", pod.Namespace, pod.Name)); err != nil { - mizu.Log.Errorf("Failed write logs, %v", err) - } else { - mizu.Log.Infof("Successfully added log length %d from pod: %s.%s", len(logs), pod.Namespace, pod.Name) - } - } - if err := AddFileToZip(zipWriter, mizu.GetConfigFilePath()); err != nil { - mizu.Log.Debugf("Failed write file, %v", err) - } else { - mizu.Log.Infof("Successfully added file %s", mizu.GetConfigFilePath()) - } - if err := AddFileToZip(zipWriter, mizu.GetLogFilePath()); err != nil { - mizu.Log.Debugf("Failed write file, %v", err) - } else { - mizu.Log.Infof("Successfully added file %s", mizu.GetLogFilePath()) - } - mizu.Log.Infof("You can find the zip with all logs in %s\n", filePath) - return nil -} diff --git a/cli/kubernetes/provider.go b/cli/kubernetes/provider.go index 221895ad4..91f745b98 100644 --- a/cli/kubernetes/provider.go +++ b/cli/kubernetes/provider.go @@ -7,6 +7,7 @@ import ( "encoding/json" "errors" "fmt" + "github.com/up9inc/mizu/cli/logger" "os" "path/filepath" "regexp" @@ -562,7 +563,7 @@ func (provider *Provider) CreateConfigMap(ctx context.Context, namespace string, } func (provider *Provider) ApplyMizuTapperDaemonSet(ctx context.Context, namespace string, daemonSetName string, podImage string, tapperPodName string, apiServerPodIp string, nodeToTappedPodIPMap map[string][]string, serviceAccountName string, tapOutgoing bool) error { - mizu.Log.Debugf("Applying %d tapper deamonsets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeToTappedPodIPMap), namespace, daemonSetName, podImage, tapperPodName) + logger.Log.Debugf("Applying %d tapper deamonsets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeToTappedPodIPMap), namespace, daemonSetName, podImage, tapperPodName) if len(nodeToTappedPodIPMap) == 0 { return fmt.Errorf("Daemon set %s must tap at least 1 pod", daemonSetName) @@ -745,7 +746,7 @@ func loadKubernetesConfiguration(kubeConfigPath string) clientcmd.ClientConfig { kubeConfigPath = filepath.Join(home, ".kube", "config") } - mizu.Log.Debugf("Using kube config %s", kubeConfigPath) + logger.Log.Debugf("Using kube config %s", kubeConfigPath) configPathList := filepath.SplitList(kubeConfigPath) configLoadingRules := &clientcmd.ClientConfigLoadingRules{} if len(configPathList) <= 1 { diff --git a/cli/kubernetes/proxy.go b/cli/kubernetes/proxy.go index 5ca2eab16..44397bdc4 100644 --- a/cli/kubernetes/proxy.go +++ b/cli/kubernetes/proxy.go @@ -2,7 +2,7 @@ package kubernetes import ( "fmt" - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/logger" "k8s.io/kubectl/pkg/proxy" "net" "net/http" @@ -14,7 +14,7 @@ const k8sProxyApiPrefix = "/" const mizuServicePort = 80 func StartProxy(kubernetesProvider *Provider, mizuPort uint16, mizuNamespace string, mizuServiceName string) error { - mizu.Log.Debugf("Starting proxy. namespace: [%v], service name: [%s], port: [%v]", mizuNamespace, mizuServiceName, mizuPort) + logger.Log.Debugf("Starting proxy. namespace: [%v], service name: [%s], port: [%v]", mizuNamespace, mizuServiceName, mizuPort) filter := &proxy.FilterServer{ AcceptPaths: proxy.MakeRegexpArrayOrDie(proxy.DefaultPathAcceptRE), RejectPaths: proxy.MakeRegexpArrayOrDie(proxy.DefaultPathRejectRE), diff --git a/cli/mizu/logger.go b/cli/logger/logger.go similarity index 83% rename from cli/mizu/logger.go rename to cli/logger/logger.go index 251922263..050ccb36d 100644 --- a/cli/mizu/logger.go +++ b/cli/logger/logger.go @@ -1,7 +1,8 @@ -package mizu +package logger import ( "github.com/op/go-logging" + "github.com/up9inc/mizu/cli/mizu" "os" "path" ) @@ -13,7 +14,7 @@ var format = logging.MustStringFormatter( ) func GetLogFilePath() string { - return path.Join(GetMizuFolderPath(), "mizu_cli.log") + return path.Join(mizu.GetMizuFolderPath(), "mizu_cli.log") } func InitLogger() { @@ -34,5 +35,5 @@ func InitLogger() { logging.SetBackend(backend1Leveled, backend2Formatter) Log.Debugf("\n\n\n") - Log.Debugf("Running mizu version %v", SemVer) + Log.Debugf("Running mizu version %v", mizu.SemVer) } diff --git a/cli/mizu.go b/cli/mizu.go index 6dc698567..05d692c66 100644 --- a/cli/mizu.go +++ b/cli/mizu.go @@ -2,7 +2,7 @@ package main import ( "github.com/up9inc/mizu/cli/cmd" - "github.com/up9inc/mizu/cli/goUtils" + "github.com/up9inc/mizu/cli/mizu/goUtils" ) func main() { diff --git a/cli/fsUtils/dirUtils.go b/cli/mizu/fsUtils/dirUtils.go similarity index 100% rename from cli/fsUtils/dirUtils.go rename to cli/mizu/fsUtils/dirUtils.go diff --git a/cli/mizu/fsUtils/mizuLogsUtils.go b/cli/mizu/fsUtils/mizuLogsUtils.go new file mode 100644 index 000000000..e063fb84c --- /dev/null +++ b/cli/mizu/fsUtils/mizuLogsUtils.go @@ -0,0 +1,60 @@ +package fsUtils + +import ( + "archive/zip" + "context" + "fmt" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/kubernetes" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu" + "os" + "regexp" +) + +func DumpLogs(provider *kubernetes.Provider, ctx context.Context, filePath string) error { + podExactRegex := regexp.MustCompile("^" + mizu.MizuResourcesPrefix) + pods, err := provider.ListAllPodsMatchingRegex(ctx, podExactRegex, []string{config.Config.MizuResourcesNamespace}) + if err != nil { + return err + } + + if len(pods) == 0 { + return fmt.Errorf("no mizu pods found in namespace %s", config.Config.MizuResourcesNamespace) + } + + newZipFile, err := os.Create(filePath) + if err != nil { + return err + } + defer newZipFile.Close() + zipWriter := zip.NewWriter(newZipFile) + defer zipWriter.Close() + + for _, pod := range pods { + logs, err := provider.GetPodLogs(pod.Namespace, pod.Name, ctx) + if err != nil { + logger.Log.Errorf("Failed to get logs, %v", err) + continue + } else { + logger.Log.Debugf("Successfully read log length %d for pod: %s.%s", len(logs), pod.Namespace, pod.Name) + } + if err := AddStrToZip(zipWriter, logs, fmt.Sprintf("%s.%s.log", pod.Namespace, pod.Name)); err != nil { + logger.Log.Errorf("Failed write logs, %v", err) + } else { + logger.Log.Infof("Successfully added log length %d from pod: %s.%s", len(logs), pod.Namespace, pod.Name) + } + } + if err := AddFileToZip(zipWriter, config.GetConfigFilePath()); err != nil { + logger.Log.Debugf("Failed write file, %v", err) + } else { + logger.Log.Infof("Successfully added file %s", config.GetConfigFilePath()) + } + if err := AddFileToZip(zipWriter, logger.GetLogFilePath()); err != nil { + logger.Log.Debugf("Failed write file, %v", err) + } else { + logger.Log.Infof("Successfully added file %s", logger.GetLogFilePath()) + } + logger.Log.Infof("You can find the zip with all logs in %s\n", filePath) + return nil +} diff --git a/cli/fsUtils/zipUtils.go b/cli/mizu/fsUtils/zipUtils.go similarity index 100% rename from cli/fsUtils/zipUtils.go rename to cli/mizu/fsUtils/zipUtils.go diff --git a/cli/goUtils/funcWrappers.go b/cli/mizu/goUtils/funcWrappers.go similarity index 81% rename from cli/goUtils/funcWrappers.go rename to cli/mizu/goUtils/funcWrappers.go index ad71b684b..fd1f5b1ce 100644 --- a/cli/goUtils/funcWrappers.go +++ b/cli/mizu/goUtils/funcWrappers.go @@ -1,7 +1,7 @@ package goUtils import ( - "github.com/up9inc/mizu/cli/mizu" + "github.com/up9inc/mizu/cli/logger" "reflect" "runtime/debug" ) @@ -10,7 +10,7 @@ func HandleExcWrapper(fn interface{}, params ...interface{}) (result []reflect.V defer func() { if panicMessage := recover(); panicMessage != nil { stack := debug.Stack() - mizu.Log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack) + logger.Log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack) } }() f := reflect.ValueOf(fn) diff --git a/cli/mizu/versionCheck.go b/cli/mizu/version/versionCheck.go similarity index 62% rename from cli/mizu/versionCheck.go rename to cli/mizu/version/versionCheck.go index 74a5c84e3..8ac0a356d 100644 --- a/cli/mizu/versionCheck.go +++ b/cli/mizu/version/versionCheck.go @@ -1,9 +1,11 @@ -package mizu +package version import ( "context" "encoding/json" "fmt" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu" "io/ioutil" "net/http" "net/url" @@ -41,22 +43,22 @@ func CheckVersionCompatibility(port uint16) (bool, error) { return false, err } - if semver.SemVersion(apiSemVer).Major() == semver.SemVersion(SemVer).Major() && - semver.SemVersion(apiSemVer).Minor() == semver.SemVersion(SemVer).Minor() { + if semver.SemVersion(apiSemVer).Major() == semver.SemVersion(mizu.SemVer).Major() && + semver.SemVersion(apiSemVer).Minor() == semver.SemVersion(mizu.SemVer).Minor() { return true, nil } - Log.Errorf(uiUtils.Red, fmt.Sprintf("cli version (%s) is not compatible with api version (%s)", SemVer, apiSemVer)) + logger.Log.Errorf(uiUtils.Red, fmt.Sprintf("cli version (%s) is not compatible with api version (%s)", mizu.SemVer, apiSemVer)) return false, nil } func CheckNewerVersion() { - Log.Debugf("Checking for newer version...") + logger.Log.Debugf("Checking for newer version...") start := time.Now() client := github.NewClient(nil) latestRelease, _, err := client.Repositories.GetLatestRelease(context.Background(), "up9inc", "mizu") if err != nil { - Log.Debugf("[ERROR] Failed to get latest release") + logger.Log.Debugf("[ERROR] Failed to get latest release") return } @@ -68,26 +70,26 @@ func CheckNewerVersion() { } } if versionFileUrl == "" { - Log.Debugf("[ERROR] Version file not found in the latest release") + logger.Log.Debugf("[ERROR] Version file not found in the latest release") return } res, err := http.Get(versionFileUrl) if err != nil { - Log.Debugf("[ERROR] Failed to get the version file %v", err) + logger.Log.Debugf("[ERROR] Failed to get the version file %v", err) return } data, err := ioutil.ReadAll(res.Body) res.Body.Close() if err != nil { - Log.Debugf("[ERROR] Failed to read the version file -> %v", err) + logger.Log.Debugf("[ERROR] Failed to read the version file -> %v", err) return } gitHubVersion := string(data) gitHubVersion = gitHubVersion[:len(gitHubVersion)-1] - Log.Debugf("Finished version validation, took %v", time.Since(start)) - if SemVer < gitHubVersion { - Log.Infof(uiUtils.Yellow, fmt.Sprintf("Update available! %v -> %v (%v)", SemVer, gitHubVersion, *latestRelease.HTMLURL)) + logger.Log.Debugf("Finished version validation, took %v", time.Since(start)) + if mizu.SemVer < gitHubVersion { + logger.Log.Infof(uiUtils.Yellow, fmt.Sprintf("Update available! %v -> %v (%v)", mizu.SemVer, gitHubVersion, *latestRelease.HTMLURL)) } } diff --git a/cli/mizu/telemetry.go b/cli/telemetry/telemetry.go similarity index 52% rename from cli/mizu/telemetry.go rename to cli/telemetry/telemetry.go index cb108cd43..6dd438877 100644 --- a/cli/mizu/telemetry.go +++ b/cli/telemetry/telemetry.go @@ -1,22 +1,25 @@ -package mizu +package telemetry import ( "bytes" "encoding/json" "fmt" + "github.com/up9inc/mizu/cli/config" + "github.com/up9inc/mizu/cli/logger" + "github.com/up9inc/mizu/cli/mizu" "net/http" ) const telemetryUrl = "https://us-east4-up9-prod.cloudfunctions.net/mizu-telemetry" func ReportRun(cmd string, args interface{}) { - if !Config.Telemetry { - Log.Debugf("not reporting due to config value") + if !config.Config.Telemetry { + logger.Log.Debugf("not reporting due to config value") return } - if Branch != "main" && Branch != "develop" { - Log.Debugf("not reporting telemetry on private branches") + if mizu.Branch != "main" && mizu.Branch != "develop" { + logger.Log.Debugf("not reporting telemetry on private branches") } argsBytes, _ := json.Marshal(args) @@ -25,16 +28,16 @@ func ReportRun(cmd string, args interface{}) { "cmd": cmd, "args": string(argsBytes), "component": "mizu_cli", - "BuildTimestamp": BuildTimestamp, - "Branch": Branch, - "version": SemVer} + "BuildTimestamp": mizu.BuildTimestamp, + "Branch": mizu.Branch, + "version": mizu.SemVer} argsMap["message"] = fmt.Sprintf("mizu %v - %v", argsMap["cmd"], string(argsBytes)) jsonValue, _ := json.Marshal(argsMap) if resp, err := http.Post(telemetryUrl, "application/json", bytes.NewBuffer(jsonValue)); err != nil { - Log.Debugf("error sending telemetry err: %v, response %v", err, resp) + logger.Log.Debugf("error sending telemetry err: %v, response %v", err, resp) } else { - Log.Debugf("Successfully reported telemetry") + logger.Log.Debugf("Successfully reported telemetry") } }