Merge pull request #332 - update download link fix

#minor

agent/pkg/controllers/entries_controller.go

@@ -10,7 +10,6 @@ import (
 	"mizuserver/pkg/utils"
 	"mizuserver/pkg/validation"
 	"net/http"
-	"regexp"
 	"time"
 
 	"github.com/google/martian/har"
@@ -65,54 +64,31 @@ func GetEntries(c *gin.Context) {
 	c.JSON(http.StatusOK, baseEntries)
 }
 
-func SyncEntries(c *gin.Context) {
-	rlog.Infof("Sync entries - started\n")
+func UploadEntries(c *gin.Context) {
+	rlog.Infof("Upload entries - started\n")
 
-	syncParams := &models.SyncEntriesRequestQuery{}
-	if err := c.BindQuery(syncParams); err != nil {
+	uploadParams := &models.UploadEntriesRequestQuery{}
+	if err := c.BindQuery(uploadParams); err != nil {
 		c.JSON(http.StatusBadRequest, err)
 		return
 	}
-
-	if err := validation.Validate(syncParams); err != nil {
+	if err := validation.Validate(uploadParams); err != nil {
 		c.JSON(http.StatusBadRequest, err)
 		return
 	}
-
 	if up9.GetAnalyzeInfo().IsAnalyzing {
 		c.String(http.StatusBadRequest, "Cannot analyze, mizu is already analyzing")
 		return
 	}
 
-	var (
-		token, model string
-		guestMode    bool
-	)
-	if syncParams.Token == "" {
-		rlog.Infof("Sync entries - creating token. env %s\n", syncParams.Env)
-		guestToken, err := up9.CreateAnonymousToken(syncParams.Env)
-		if err != nil {
-			c.String(http.StatusServiceUnavailable, "Failed creating anonymous token")
-			return
-		}
-
-		token = guestToken.Token
-		model = guestToken.Model
-		guestMode = true
-	} else {
-		token = fmt.Sprintf("bearer %s", syncParams.Token)
-		model = syncParams.Workspace
-		guestMode = false
-	}
-
-	modelRegex, _ := regexp.Compile("[A-Za-z0-9][-A-Za-z0-9_.]*[A-Za-z0-9]+$")
-	if len(model) > 63 || !modelRegex.MatchString(model) {
-		c.String(http.StatusBadRequest, "Invalid model name")
+	rlog.Infof("Upload entries - creating token. dest %s\n", uploadParams.Dest)
+	token, err := up9.CreateAnonymousToken(uploadParams.Dest)
+	if err != nil {
+		c.String(http.StatusServiceUnavailable, "Cannot analyze, mizu is already analyzing")
 		return
 	}
-
-	rlog.Infof("Sync entries - syncing. token: %s, model: %s, guest mode: %v\n", token, model, guestMode)
-	go up9.SyncEntriesImpl(token, model, syncParams.Env, syncParams.UploadIntervalSec, guestMode)
+	rlog.Infof("Upload entries - uploading. token: %s model: %s\n", token.Token, token.Model)
+	go up9.UploadEntriesImpl(token.Token, token.Model, uploadParams.Dest, uploadParams.SleepIntervalSec)
 	c.String(http.StatusOK, "OK")
 }
 

agent/pkg/models/models.go

@@ -22,11 +22,9 @@ type EntriesFilter struct {
 	Timestamp int64  `form:"timestamp" validate:"required,min=1"`
 }
 
-type SyncEntriesRequestQuery struct {
-	Token             string `form:"token"`
-	Env               string `form:"env"`
-	Workspace         string `form:"workspace"`
-	UploadIntervalSec int    `form:"interval"`
+type UploadEntriesRequestQuery struct {
+	Dest             string `form:"dest"`
+	SleepIntervalSec int    `form:"interval"`
 }
 
 type HarFetchRequestQuery struct {

agent/pkg/routes/entries_routes.go

@@ -12,7 +12,7 @@ func EntriesRoutes(ginApp *gin.Engine) {
 	routeGroup.GET("/entries", controllers.GetEntries)        // get entries (base/thin entries)
 	routeGroup.GET("/entries/:entryId", controllers.GetEntry) // get single (full) entry
 	routeGroup.GET("/exportEntries", controllers.GetFullEntries)
-	routeGroup.GET("/syncEntries", controllers.SyncEntries)
+	routeGroup.GET("/uploadEntries", controllers.UploadEntries)
 	routeGroup.GET("/resolving", controllers.GetCurrentResolvingInformation)
 
 	routeGroup.GET("/resetDB", controllers.DeleteAllEntries)     // get single (full) entry

agent/pkg/up9/main.go

@@ -59,16 +59,14 @@ func GetRemoteUrl(analyzeDestination string, analyzeToken string) string {
 	return fmt.Sprintf("https://%s/share/%s", analyzeDestination, analyzeToken)
 }
 
-func CheckIfModelReady(analyzeDestination string, analyzeModel string, analyzeToken string, guestMode bool) bool {
+func CheckIfModelReady(analyzeDestination string, analyzeModel string, analyzeToken string) bool {
 	statusUrl, _ := url.Parse(fmt.Sprintf("https://trcc.%s/models/%s/status", analyzeDestination, analyzeModel))
-
-	authHeader := getAuthHeader(guestMode)
 	req := &http.Request{
 		Method: http.MethodGet,
 		URL:    statusUrl,
 		Header: map[string][]string{
 			"Content-Type": {"application/json"},
-			authHeader:     {analyzeToken},
+			"Guest-Auth":   {analyzeToken},
 		},
 	}
 	statusResp, err := http.DefaultClient.Do(req)
@@ -83,14 +81,6 @@ func CheckIfModelReady(analyzeDestination string, analyzeModel string, analyzeTo
 	return target.LastMajorGeneration > 0
 }
 
-func getAuthHeader(guestMode bool) string {
-	if guestMode {
-		return "Guest-Auth"
-	}
-
-	return "Authorization"
-}
-
 func GetTrafficDumpUrl(analyzeDestination string, analyzeModel string) *url.URL {
 	strUrl := fmt.Sprintf("https://traffic.%s/dumpTrafficBulk/%s", analyzeDestination, analyzeModel)
 	if strings.HasPrefix(analyzeDestination, "http") {
@@ -102,7 +92,6 @@ func GetTrafficDumpUrl(analyzeDestination string, analyzeModel string) *url.URL
 
 type AnalyzeInformation struct {
 	IsAnalyzing        bool
-	GuestMode          bool
 	SentCount          int
 	AnalyzedModel      string
 	AnalyzeToken       string
@@ -111,7 +100,6 @@ type AnalyzeInformation struct {
 
 func (info *AnalyzeInformation) Reset() {
 	info.IsAnalyzing = false
-	info.GuestMode = true
 	info.AnalyzedModel = ""
 	info.AnalyzeToken = ""
 	info.AnalyzeDestination = ""
@@ -124,20 +112,19 @@ func GetAnalyzeInfo() *shared.AnalyzeStatus {
 	return &shared.AnalyzeStatus{
 		IsAnalyzing:   analyzeInformation.IsAnalyzing,
 		RemoteUrl:     GetRemoteUrl(analyzeInformation.AnalyzeDestination, analyzeInformation.AnalyzeToken),
-		IsRemoteReady: CheckIfModelReady(analyzeInformation.AnalyzeDestination, analyzeInformation.AnalyzedModel, analyzeInformation.AnalyzeToken, analyzeInformation.GuestMode),
+		IsRemoteReady: CheckIfModelReady(analyzeInformation.AnalyzeDestination, analyzeInformation.AnalyzedModel, analyzeInformation.AnalyzeToken),
 		SentCount:     analyzeInformation.SentCount,
 	}
 }
 
-func SyncEntriesImpl(token string, model string, envPrefix string, uploadIntervalSec int, guestMode bool) {
+func UploadEntriesImpl(token string, model string, envPrefix string, sleepIntervalSec int) {
 	analyzeInformation.IsAnalyzing = true
-	analyzeInformation.GuestMode = guestMode
 	analyzeInformation.AnalyzedModel = model
 	analyzeInformation.AnalyzeToken = token
 	analyzeInformation.AnalyzeDestination = envPrefix
 	analyzeInformation.SentCount = 0
 
-	sleepTime := time.Second * time.Duration(uploadIntervalSec)
+	sleepTime := time.Second * time.Duration(sleepIntervalSec)
 
 	var timestampFrom int64 = 0
 
@@ -173,7 +160,7 @@ func SyncEntriesImpl(token string, model string, envPrefix string, uploadInterva
 			body, jMarshalErr := json.Marshal(result)
 			if jMarshalErr != nil {
 				analyzeInformation.Reset()
-				rlog.Infof("Stopping sync entries")
+				rlog.Infof("Stopping analyzing")
 				log.Fatal(jMarshalErr)
 			}
 
@@ -183,21 +170,20 @@ func SyncEntriesImpl(token string, model string, envPrefix string, uploadInterva
 			_ = w.Close()
 			reqBody := ioutil.NopCloser(bytes.NewReader(in.Bytes()))
 
-			authHeader := getAuthHeader(guestMode)
 			req := &http.Request{
 				Method: http.MethodPost,
 				URL:    GetTrafficDumpUrl(envPrefix, model),
 				Header: map[string][]string{
 					"Content-Encoding": {"deflate"},
 					"Content-Type":     {"application/octet-stream"},
-					authHeader:         {token},
+					"Guest-Auth":       {token},
 				},
 				Body: reqBody,
 			}
 
 			if _, postErr := http.DefaultClient.Do(req); postErr != nil {
 				analyzeInformation.Reset()
-				rlog.Info("Stopping sync entries")
+				rlog.Info("Stopping analyzing")
 				log.Fatal(postErr)
 			}
 			analyzeInformation.SentCount += len(entriesArray)

cli/apiserver/provider.go

@@ -82,23 +82,23 @@ func (provider *apiServerProvider) ReportTappedPods(pods []core.Pod) error {
 	}
 }
 
-func (provider *apiServerProvider) RequestSyncEntries(analysisDestination string, sleepIntervalSec int) error {
+func (provider *apiServerProvider) RequestAnalysis(analysisDestination string, sleepIntervalSec int) error {
 	if !provider.isReady {
 		return fmt.Errorf("trying to reach api server when not initialized yet")
 	}
-	urlPath := fmt.Sprintf("%s/api/syncEntries?env=%s&interval=%v", provider.url, url.QueryEscape(analysisDestination), sleepIntervalSec)
-	syncEntriesUrl, parseErr := url.ParseRequestURI(urlPath)
+	urlPath := fmt.Sprintf("%s/api/uploadEntries?dest=%s&interval=%v", provider.url, url.QueryEscape(analysisDestination), sleepIntervalSec)
+	u, parseErr := url.ParseRequestURI(urlPath)
 	if parseErr != nil {
-		logger.Log.Fatal("Failed parsing the URL (consider changing the env name), err: %v", parseErr)
+		logger.Log.Fatal("Failed parsing the URL (consider changing the analysis dest URL), err: %v", parseErr)
 	}
 
-	logger.Log.Debugf("Sync entries url %v", syncEntriesUrl.String())
-	if response, requestErr := http.Get(syncEntriesUrl.String()); requestErr != nil {
-		return fmt.Errorf("failed to notify api server for sync entries, err: %w", requestErr)
+	logger.Log.Debugf("Analysis url %v", u.String())
+	if response, requestErr := http.Get(u.String()); requestErr != nil {
+		return fmt.Errorf("failed to notify agent for analysis, err: %w", requestErr)
 	} else if response.StatusCode != 200 {
-		return fmt.Errorf("failed to notify api server for sync entries, status code: %v", response.StatusCode)
+		return fmt.Errorf("failed to notify agent for analysis, status code: %v", response.StatusCode)
 	} else {
-		logger.Log.Infof(uiUtils.Purple, "Entries are syncing to UP9 for further analysis")
+		logger.Log.Infof(uiUtils.Purple, "Traffic is uploading to UP9 for further analysis")
 		return nil
 	}
 }

cli/auth/authProvider.go

@@ -1,176 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/creasty/defaults"
-	"github.com/golang-jwt/jwt/v4"
-	"github.com/google/uuid"
-	"github.com/up9inc/mizu/cli/config"
-	"github.com/up9inc/mizu/cli/config/configStructs"
-	"github.com/up9inc/mizu/cli/logger"
-	"github.com/up9inc/mizu/cli/uiUtils"
-	"golang.org/x/oauth2"
-	"net"
-	"net/http"
-	"os"
-	"time"
-)
-
-const loginTimeoutInMin = 2
-
-// Ports are configured in keycloak "cli" client as valid redirect URIs. A change here must be reflected there as well.
-var listenPorts = []int{3141, 4001, 5002, 6003, 7004, 8005, 9006, 10007}
-
-func IsTokenExpired(tokenString string) (bool, error) {
-	token, _, err := new(jwt.Parser).ParseUnverified(tokenString, jwt.MapClaims{})
-	if err != nil {
-		return true, fmt.Errorf("failed to parse token, err: %v", err)
-	}
-
-	claims, ok := token.Claims.(jwt.MapClaims)
-	if !ok {
-		return true, fmt.Errorf("can't convert token's claims to standard claims")
-	}
-
-	expiry := time.Unix(int64(claims["exp"].(float64)), 0)
-
-	return time.Now().After(expiry), nil
-}
-
-func Login() error {
-	token, err := loginInteractively()
-	if err != nil {
-		return fmt.Errorf("failed login interactively, err: %v", err)
-	}
-
-	authConfig := configStructs.AuthConfig{
-		EnvName: config.Config.Auth.EnvName,
-		Token:   token.AccessToken,
-	}
-
-	configFile := config.ConfigStruct{}
-	if err := defaults.Set(&configFile); err != nil {
-		return fmt.Errorf("failed inserting default values to config, err: %v", err)
-	}
-
-	if err := config.LoadConfigFile(config.Config.ConfigFilePath, &configFile); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("failed getting config file, err: %v", err)
-	}
-
-	configFile.Auth = authConfig
-
-	if err := config.WriteConfig(&configFile); err != nil {
-		return fmt.Errorf("failed writing config with auth, err: %v", err)
-	}
-
-	config.Config.Auth = authConfig
-
-	logger.Log.Infof("Login successfully, token stored in config path: %s", fmt.Sprintf(uiUtils.Purple, config.Config.ConfigFilePath))
-	return nil
-}
-
-func loginInteractively() (*oauth2.Token, error) {
-	tokenChannel := make(chan *oauth2.Token)
-	errorChannel := make(chan error)
-
-	server := http.Server{}
-	go startLoginServer(tokenChannel, errorChannel, &server)
-
-	defer func() {
-		if err := server.Shutdown(context.Background()); err != nil {
-			logger.Log.Debugf("Error shutting down server, err: %v", err)
-		}
-	}()
-
-	select {
-	case <-time.After(loginTimeoutInMin * time.Minute):
-		return nil, errors.New("auth timed out")
-	case err := <-errorChannel:
-		return nil, err
-	case token := <-tokenChannel:
-		return token, nil
-	}
-}
-
-func startLoginServer(tokenChannel chan *oauth2.Token, errorChannel chan error, server *http.Server) {
-	for _, port := range listenPorts {
-		var authConfig = &oauth2.Config{
-			ClientID:    "cli",
-			RedirectURL: fmt.Sprintf("http://localhost:%v/callback", port),
-			Endpoint: oauth2.Endpoint{
-				AuthURL:  fmt.Sprintf("https://auth.%s/auth/realms/testr/protocol/openid-connect/auth", config.Config.Auth.EnvName),
-				TokenURL: fmt.Sprintf("https://auth.%s/auth/realms/testr/protocol/openid-connect/token", config.Config.Auth.EnvName),
-			},
-		}
-
-		state := uuid.New()
-
-		mux := http.NewServeMux()
-		server.Handler = mux
-		mux.Handle("/callback", loginCallbackHandler(tokenChannel, errorChannel, authConfig, state))
-
-		listener, listenErr := net.Listen("tcp", fmt.Sprintf("%s:%d", "127.0.0.1", port))
-		if listenErr != nil {
-			logger.Log.Debugf("failed to start listening on port %v, err: %v", port, listenErr)
-			continue
-		}
-
-		authorizationUrl := authConfig.AuthCodeURL(state.String())
-		uiUtils.OpenBrowser(authorizationUrl)
-
-		serveErr := server.Serve(listener)
-		if serveErr == http.ErrServerClosed {
-			logger.Log.Debugf("received server shutdown, server on port %v is closed", port)
-			return
-		} else if serveErr != nil {
-			logger.Log.Debugf("failed to start serving on port %v, err: %v", port, serveErr)
-			continue
-		}
-
-		logger.Log.Debugf("didn't receive server closed on port %v", port)
-		return
-	}
-
-	errorChannel <- fmt.Errorf("failed to start serving on all listen ports, ports: %v", listenPorts)
-}
-
-func loginCallbackHandler(tokenChannel chan *oauth2.Token, errorChannel chan error, authConfig *oauth2.Config, state uuid.UUID) http.Handler {
-	return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-		if err := request.ParseForm(); err != nil {
-			errorMsg := fmt.Sprintf("failed to parse form, err: %v", err)
-			http.Error(writer, errorMsg, http.StatusBadRequest)
-			errorChannel <- fmt.Errorf(errorMsg)
-			return
-		}
-
-		requestState := request.Form.Get("state")
-		if requestState != state.String() {
-			errorMsg := fmt.Sprintf("state invalid, requestState: %v, authState:%v", requestState, state.String())
-			http.Error(writer, errorMsg, http.StatusBadRequest)
-			errorChannel <- fmt.Errorf(errorMsg)
-			return
-		}
-
-		code := request.Form.Get("code")
-		if code == "" {
-			errorMsg := "code not found"
-			http.Error(writer, errorMsg, http.StatusBadRequest)
-			errorChannel <- fmt.Errorf(errorMsg)
-			return
-		}
-
-		token, err := authConfig.Exchange(context.Background(), code)
-		if err != nil {
-			errorMsg := fmt.Sprintf("failed to create token, err: %v", err)
-			http.Error(writer, errorMsg, http.StatusInternalServerError)
-			errorChannel <- fmt.Errorf(errorMsg)
-			return
-		}
-
-		tokenChannel <- token
-
-		http.Redirect(writer, request, fmt.Sprintf("https://%s/CliLogin", config.Config.Auth.EnvName), http.StatusFound)
-	})
-}

cli/cmd/common.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"os/exec"
 	"os/signal"
+	"runtime"
 	"syscall"
 
 	"github.com/up9inc/mizu/cli/config"
@@ -47,3 +49,21 @@ func waitForFinish(ctx context.Context, cancel context.CancelFunc) {
 	}
 }
 
+func openBrowser(url string) {
+	var err error
+
+	switch runtime.GOOS {
+	case "linux":
+		err = exec.Command("xdg-open", url).Start()
+	case "windows":
+		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
+	case "darwin":
+		err = exec.Command("open", url).Start()
+	default:
+		err = fmt.Errorf("unsupported platform")
+	}
+
+	if err != nil {
+		logger.Log.Errorf("error while opening browser, %v", err)
+	}
+}

cli/cmd/config.go

@@ -9,6 +9,7 @@ import (
 	"github.com/up9inc/mizu/cli/logger"
 	"github.com/up9inc/mizu/cli/telemetry"
 	"github.com/up9inc/mizu/cli/uiUtils"
+	"io/ioutil"
 )
 
 var configCmd = &cobra.Command{
@@ -17,30 +18,22 @@ var configCmd = &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		go telemetry.ReportRun("config", config.Config.Config)
 
-		configWithDefaults, err := config.GetConfigWithDefaults()
+		template, err := config.GetConfigWithDefaults()
 		if err != nil {
-			logger.Log.Errorf("Failed generating config with defaults, err: %v", err)
+			logger.Log.Errorf("Failed generating config with defaults %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)
+			data := []byte(template)
+			if err := ioutil.WriteFile(config.Config.ConfigFilePath, data, 0644); err != nil {
+				logger.Log.Errorf("Failed writing config %v", err)
 				return nil
 			}
-
 			logger.Log.Infof(fmt.Sprintf("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)
-				return nil
-			}
-
 			logger.Log.Debugf("Writing template config.\n%v", template)
 			fmt.Printf("%v", template)
 		}
-
 		return nil
 	},
 }

cli/cmd/tapRunner.go

@@ -578,8 +578,8 @@ func watchApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 				}
 
 				logger.Log.Infof("Mizu is available at %s\n", url)
-				uiUtils.OpenBrowser(url)
-				requestForSyncEntriesIfNeeded()
+				openBrowser(url)
+				requestForAnalysisIfNeeded()
 				if err := apiserver.Provider.ReportTappedPods(state.currentlyTappedPods); err != nil {
 					logger.Log.Debugf("[Error] failed update tapped pods %v", err)
 				}
@@ -632,7 +632,7 @@ func watchTapperPod(ctx context.Context, kubernetesProvider *kubernetes.Provider
 			}
 
 			if modifiedPod.Status.Phase == core.PodPending && modifiedPod.Status.Conditions[0].Type == core.PodScheduled && modifiedPod.Status.Conditions[0].Status != core.ConditionTrue {
-				logger.Log.Infof(uiUtils.Red, fmt.Sprintf("Wasn't able to deploy the tapper %s. Reason: \"%s\"", modifiedPod.Name, modifiedPod.Status.Conditions[0].Message))
+				logger.Log.Infof(uiUtils.Red, "Wasn't able to deploy the tapper %s. Reason: \"%s\"", modifiedPod.Name, modifiedPod.Status.Conditions[0].Message)
 				cancel()
 				break
 			}
@@ -649,7 +649,7 @@ func watchTapperPod(ctx context.Context, kubernetesProvider *kubernetes.Provider
 				if state.Terminated != nil {
 					switch state.Terminated.Reason {
 					case "OOMKilled":
-						logger.Log.Infof(uiUtils.Red, fmt.Sprintf("Tapper %s was terminated (reason: OOMKilled). You should consider increasing machine resources.", modifiedPod.Name))
+						logger.Log.Infof(uiUtils.Red, "Tapper %s was terminated (reason: OOMKilled). You should consider increasing machine resources.", modifiedPod.Name)
 					}
 				}
 			}
@@ -671,12 +671,12 @@ func watchTapperPod(ctx context.Context, kubernetesProvider *kubernetes.Provider
 	}
 }
 
-func requestForSyncEntriesIfNeeded() {
+func requestForAnalysisIfNeeded() {
 	if !config.Config.Tap.Analysis {
 		return
 	}
-	if err := apiserver.Provider.RequestSyncEntries(config.Config.Tap.AnalysisDestination, config.Config.Tap.UploadIntervalSec); err != nil {
-		logger.Log.Debugf("[Error] failed requesting for sync entries, err: %v", err)
+	if err := apiserver.Provider.RequestAnalysis(config.Config.Tap.AnalysisDestination, config.Config.Tap.SleepIntervalSec); err != nil {
+		logger.Log.Debugf("[Error] failed requesting for analysis %v", err)
 	}
 }
 

cli/cmd/viewRunner.go

@@ -57,8 +57,7 @@ func runMizuView() {
 
 	logger.Log.Infof("Mizu is available at %s\n", url)
 
-	uiUtils.OpenBrowser(url)
-
+	openBrowser(url)
 	if isCompatible, err := version.CheckVersionCompatibility(); err != nil {
 		logger.Log.Errorf("Failed to check versions compatibility %v", err)
 		cancel()

cli/config/config.go

@@ -39,7 +39,7 @@ func InitConfig(cmd *cobra.Command) error {
 
 	configFilePathFlag := cmd.Flags().Lookup(ConfigFilePathCommandName)
 	configFilePath := configFilePathFlag.Value.String()
-	if err := LoadConfigFile(configFilePath, &Config); err != nil {
+	if err := mergeConfigFile(configFilePath); err != nil {
 		if configFilePathFlag.Changed || !os.IsNotExist(err) {
 			return fmt.Errorf("invalid config, %w\n"+
 				"you can regenerate the file by removing it (%v) and using `mizu config -r`", err, configFilePath)
@@ -54,33 +54,19 @@ func InitConfig(cmd *cobra.Command) error {
 	return nil
 }
 
-func GetConfigWithDefaults() (*ConfigStruct, error) {
+func GetConfigWithDefaults() (string, error) {
 	defaultConf := ConfigStruct{}
 	if err := defaults.Set(&defaultConf); err != nil {
-		return nil, err
+		return "", err
 	}
 
 	configElem := reflect.ValueOf(&defaultConf).Elem()
 	setZeroForReadonlyFields(configElem)
 
-	return &defaultConf, nil
+	return uiUtils.PrettyYaml(defaultConf)
 }
 
-func WriteConfig(config *ConfigStruct) error {
-	template, err := uiUtils.PrettyYaml(config)
-	if err != nil {
-		return fmt.Errorf("failed converting config to yaml, err: %v", err)
-	}
-
-	data := []byte(template)
-	if err := ioutil.WriteFile(Config.ConfigFilePath, data, 0644); err != nil {
-		return fmt.Errorf("failed writing config, err: %v", err)
-	}
-
-	return nil
-}
-
-func LoadConfigFile(configFilePath string, config *ConfigStruct) error {
+func mergeConfigFile(configFilePath string) error {
 	reader, openErr := os.Open(configFilePath)
 	if openErr != nil {
 		return openErr
@@ -91,11 +77,10 @@ func LoadConfigFile(configFilePath string, config *ConfigStruct) error {
 		return readErr
 	}
 
-	if err := yaml.Unmarshal(buf, config); err != nil {
+	if err := yaml.Unmarshal(buf, &Config); err != nil {
 		return err
 	}
-
-	logger.Log.Debugf("Found config file, config path: %s", configFilePath)
+	logger.Log.Debugf("Found config file, merged to default options")
 
 	return nil
 }

cli/config/configStruct.go

@@ -21,7 +21,6 @@ type ConfigStruct struct {
 	Version                configStructs.VersionConfig `yaml:"version"`
 	View                   configStructs.ViewConfig    `yaml:"view"`
 	Logs                   configStructs.LogsConfig    `yaml:"logs"`
-	Auth                   configStructs.AuthConfig    `yaml:"auth"`
 	Config                 configStructs.ConfigConfig  `yaml:"config,omitempty"`
 	AgentImage             string                      `yaml:"agent-image,omitempty" readonly:""`
 	ImagePullPolicyStr     string                      `yaml:"image-pull-policy" default:"Always"`

cli/config/configStructs/authConfig.go

@@ -1,6 +0,0 @@
-package configStructs
-
-type AuthConfig struct {
-	EnvName      string    `yaml:"env-name" default:"up9.app"`
-	Token        string    `yaml:"token"`
-}

cli/config/configStructs/tapConfig.go

@@ -20,21 +20,21 @@ const (
 )
 
 type TapConfig struct {
-	AnalysisDestination    string    `yaml:"dest" default:"up9.app"`
-	UploadIntervalSec      int       `yaml:"upload-interval" default:"10"`
-	PodRegexStr            string    `yaml:"regex" default:".*"`
-	GuiPort                uint16    `yaml:"gui-port" default:"8899"`
-	Namespaces             []string  `yaml:"namespaces"`
-	Analysis               bool      `yaml:"analysis" default:"false"`
-	AllNamespaces          bool      `yaml:"all-namespaces" default:"false"`
-	PlainTextFilterRegexes []string  `yaml:"regex-masking"`
-	IgnoredUserAgents      []string  `yaml:"ignored-user-agents"`
-	DisableRedaction       bool      `yaml:"no-redact" default:"false"`
-	HumanMaxEntriesDBSize  string    `yaml:"max-entries-db-size" default:"200MB"`
-	DryRun                 bool      `yaml:"dry-run" default:"false"`
-	EnforcePolicyFile      string    `yaml:"traffic-validation-file"`
-	ApiServerResources     Resources `yaml:"api-server-resources"`
-	TapperResources        Resources `yaml:"tapper-resources"`
+	AnalysisDestination         string    `yaml:"dest" default:"up9.app"`
+	SleepIntervalSec            int       `yaml:"upload-interval" default:"10"`
+	PodRegexStr                 string    `yaml:"regex" default:".*"`
+	GuiPort                     uint16    `yaml:"gui-port" default:"8899"`
+	Namespaces                  []string  `yaml:"namespaces"`
+	Analysis                    bool      `yaml:"analysis" default:"false"`
+	AllNamespaces               bool      `yaml:"all-namespaces" default:"false"`
+	PlainTextFilterRegexes      []string  `yaml:"regex-masking"`
+	IgnoredUserAgents           []string  `yaml:"ignored-user-agents"`
+	DisableRedaction            bool      `yaml:"no-redact" default:"false"`
+	HumanMaxEntriesDBSize       string    `yaml:"max-entries-db-size" default:"200MB"`
+	DryRun                      bool      `yaml:"dry-run" default:"false"`
+	EnforcePolicyFile           string    `yaml:"traffic-validation-file"`
+	ApiServerResources          Resources `yaml:"api-server-resources"`
+	TapperResources             Resources `yaml:"tapper-resources"`
 }
 
 type Resources struct {

cli/config/config_test.go

@@ -3,7 +3,6 @@ package config_test
 import (
 	"fmt"
 	"github.com/up9inc/mizu/cli/config"
-	"gopkg.in/yaml.v3"
 	"reflect"
 	"strings"
 	"testing"
@@ -16,11 +15,10 @@ func TestConfigWriteIgnoresReadonlyFields(t *testing.T) {
 	getFieldsWithReadonlyTag(configElem, &readonlyFields)
 
 	configWithDefaults, _ := config.GetConfigWithDefaults()
-	configWithDefaultsBytes, _ := yaml.Marshal(configWithDefaults)
 	for _, readonlyField := range readonlyFields {
 		t.Run(readonlyField, func(t *testing.T) {
-			readonlyFieldToCheck := fmt.Sprintf(" %s:", readonlyField)
-			if strings.Contains(string(configWithDefaultsBytes), readonlyFieldToCheck) {
+			readonlyFieldToCheck := fmt.Sprintf("\n%s:", readonlyField)
+			if strings.Contains(configWithDefaults, readonlyFieldToCheck) {
 				t.Errorf("unexpected result - readonly field: %v, config: %v", readonlyField, configWithDefaults)
 			}
 		})

cli/go.mod

@@ -5,15 +5,13 @@ go 1.16
 require (
 	github.com/creasty/defaults v1.5.1
 	github.com/denisbrodbeck/machineid v1.0.1
-	github.com/golang-jwt/jwt/v4 v4.1.0
 	github.com/google/go-github/v37 v37.0.0
-	github.com/google/uuid v1.1.2
+	github.com/gorilla/websocket v1.4.2
 	github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
 	github.com/spf13/cobra v1.1.3
 	github.com/spf13/pflag v1.0.5
 	github.com/up9inc/mizu/shared v0.0.0
 	github.com/up9inc/mizu/tap/api v0.0.0
-	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 	k8s.io/api v0.21.2
 	k8s.io/apimachinery v0.21.2

cli/go.sum

@@ -175,8 +175,6 @@ github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7a
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang-jwt/jwt/v4 v4.1.0 h1:XUgk2Ex5veyVFVeLm0xhusUTQybEbexJXrvPNOKkSY0=
-github.com/golang-jwt/jwt/v4 v4.1.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
@@ -239,6 +237,7 @@ github.com/googleapis/gnostic v0.4.1 h1:DLJCy1n/vrD4HPjOvYcT8aYQXpPIzoRZONaYwyyc
 github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=

cli/mizu/version/versionCheck.go

@@ -75,12 +75,6 @@ func CheckNewerVersion(versionChan chan string) {
 
 	gitHubVersionSemVer := semver.SemVersion(gitHubVersion)
 	currentSemVer := semver.SemVersion(mizu.SemVer)
-	if !gitHubVersionSemVer.IsValid() || !currentSemVer.IsValid() {
-		logger.Log.Debugf("[ERROR] Semver version is not valid, github version %v, current version %v", gitHubVersion, currentSemVer)
-		versionChan <- ""
-		return
-	}
-
 	logger.Log.Debugf("Finished version validation, github version %v, current version %v, took %v", gitHubVersion, currentSemVer, time.Since(start))
 
 	if gitHubVersionSemVer.GreaterThan(currentSemVer) {

cli/uiUtils/openBrowser.go

@@ -1,27 +0,0 @@
-package uiUtils
-
-import (
-	"fmt"
-	"github.com/up9inc/mizu/cli/logger"
-	"os/exec"
-	"runtime"
-)
-
-func OpenBrowser(url string) {
-	var err error
-
-	switch runtime.GOOS {
-	case "linux":
-		err = exec.Command("xdg-open", url).Start()
-	case "windows":
-		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
-	case "darwin":
-		err = exec.Command("open", url).Start()
-	default:
-		err = fmt.Errorf("unsupported platform")
-	}
-
-	if err != nil {
-		logger.Log.Errorf("error while opening browser, %v", err)
-	}
-}

shared/semver/semver.go

@@ -6,17 +6,9 @@ import (
 
 type SemVersion string
 
-func (v SemVersion) IsValid() bool {
-	re := regexp.MustCompile(`\d+`)
-	breakdown := re.FindAllString(string(v), 3)
-
-	return len(breakdown) == 3
-}
-
 func (v SemVersion) Breakdown() (string, string, string) {
 	re := regexp.MustCompile(`\d+`)
 	breakdown := re.FindAllString(string(v), 3)
-
 	return breakdown[0], breakdown[1], breakdown[2]
 }
 

tap/extensions/kafka/helpers.go

@@ -130,16 +130,8 @@ func representMetadataResponse(data map[string]interface{}) []interface{} {
 	rep = representResponseHeader(data, rep)
 
 	payload := data["Payload"].(map[string]interface{})
-	topics := ""
-	if payload["Topics"] != nil {
-		_topics, _ := json.Marshal(payload["Topics"].([]interface{}))
-		topics = string(_topics)
-	}
-	brokers := ""
-	if payload["Brokers"] != nil {
-		_brokers, _ := json.Marshal(payload["Brokers"].([]interface{}))
-		brokers = string(_brokers)
-	}
+	topics, _ := json.Marshal(payload["Topics"].([]interface{}))
+	brokers, _ := json.Marshal(payload["Brokers"].([]interface{}))
 	controllerID := ""
 	clusterID := ""
 	throttleTimeMs := ""
@@ -163,7 +155,7 @@ func representMetadataResponse(data map[string]interface{}) []interface{} {
 		},
 		{
 			"name":  "Brokers",
-			"value": brokers,
+			"value": string(brokers),
 		},
 		{
 			"name":  "Cluster ID",
@@ -175,7 +167,7 @@ func representMetadataResponse(data map[string]interface{}) []interface{} {
 		},
 		{
 			"name":  "Topics",
-			"value": topics,
+			"value": string(topics),
 		},
 		{
 			"name":  "Cluster Authorized Operations",
@@ -311,11 +303,7 @@ func representProduceResponse(data map[string]interface{}) []interface{} {
 	rep = representResponseHeader(data, rep)
 
 	payload := data["Payload"].(map[string]interface{})
-	responses := ""
-	if payload["Responses"] != nil {
-		_responses, _ := json.Marshal(payload["Responses"].([]interface{}))
-		responses = string(_responses)
-	}
+	responses, _ := json.Marshal(payload["Responses"].([]interface{}))
 	throttleTimeMs := ""
 	if payload["ThrottleTimeMs"] != nil {
 		throttleTimeMs = fmt.Sprintf("%d", int(payload["ThrottleTimeMs"].(float64)))
@@ -345,11 +333,7 @@ func representFetchRequest(data map[string]interface{}) []interface{} {
 	rep = representRequestHeader(data, rep)
 
 	payload := data["Payload"].(map[string]interface{})
-	topics := ""
-	if payload["Topics"] != nil {
-		_topics, _ := json.Marshal(payload["Topics"].([]interface{}))
-		topics = string(_topics)
-	}
+	topics, _ := json.Marshal(payload["Topics"].([]interface{}))
 	replicaId := ""
 	if payload["ReplicaId"] != nil {
 		replicaId = fmt.Sprintf("%d", int(payload["ReplicaId"].(float64)))
@@ -377,7 +361,7 @@ func representFetchRequest(data map[string]interface{}) []interface{} {
 	}
 	rackId := ""
 	if payload["RackId"] != nil {
-		rackId = payload["RackId"].(string)
+		rackId = fmt.Sprintf("%d", int(payload["RackId"].(float64)))
 	}
 	repPayload, _ := json.Marshal([]map[string]string{
 		{
@@ -410,7 +394,7 @@ func representFetchRequest(data map[string]interface{}) []interface{} {
 		},
 		{
 			"name":  "Topics",
-			"value": topics,
+			"value": string(topics),
 		},
 		{
 			"name":  "Forgotten Topics Data",
@@ -436,11 +420,7 @@ func representFetchResponse(data map[string]interface{}) []interface{} {
 	rep = representResponseHeader(data, rep)
 
 	payload := data["Payload"].(map[string]interface{})
-	responses := ""
-	if payload["Responses"] != nil {
-		_responses, _ := json.Marshal(payload["Responses"].([]interface{}))
-		responses = string(_responses)
-	}
+	responses, _ := json.Marshal(payload["Responses"].([]interface{}))
 	throttleTimeMs := ""
 	if payload["ThrottleTimeMs"] != nil {
 		throttleTimeMs = fmt.Sprintf("%d", int(payload["ThrottleTimeMs"].(float64)))
@@ -468,7 +448,7 @@ func representFetchResponse(data map[string]interface{}) []interface{} {
 		},
 		{
 			"name":  "Responses",
-			"value": responses,
+			"value": string(responses),
 		},
 	})
 	rep = append(rep, map[string]string{
@@ -486,11 +466,7 @@ func representListOffsetsRequest(data map[string]interface{}) []interface{} {
 	rep = representRequestHeader(data, rep)
 
 	payload := data["Payload"].(map[string]interface{})
-	topics := ""
-	if payload["Topics"] != nil {
-		_topics, _ := json.Marshal(payload["Topics"].([]interface{}))
-		topics = string(_topics)
-	}
+	topics, _ := json.Marshal(payload["Topics"].([]interface{}))
 	repPayload, _ := json.Marshal([]map[string]string{
 		{
 			"name":  "Replica ID",
@@ -498,7 +474,7 @@ func representListOffsetsRequest(data map[string]interface{}) []interface{} {
 		},
 		{
 			"name":  "Topics",
-			"value": topics,
+			"value": string(topics),
 		},
 	})
 	rep = append(rep, map[string]string{

tap/extensions/kafka/main.go

@@ -104,11 +104,7 @@ func (d dissecting) Analyze(item *api.OutputChannelItem, entryId string, resolve
 		}
 		break
 	case Fetch:
-		_topics := reqDetails["Payload"].(map[string]interface{})["Topics"]
-		if _topics == nil {
-			break
-		}
-		topics := _topics.([]interface{})
+		topics := reqDetails["Payload"].(map[string]interface{})["Topics"].([]interface{})
 		for _, topic := range topics {
 			summary += fmt.Sprintf("%s, ", topic.(map[string]interface{})["Topic"].(string))
 		}
@@ -117,11 +113,7 @@ func (d dissecting) Analyze(item *api.OutputChannelItem, entryId string, resolve
 		}
 		break
 	case ListOffsets:
-		_topics := reqDetails["Payload"].(map[string]interface{})["Topics"]
-		if _topics == nil {
-			break
-		}
-		topics := _topics.([]interface{})
+		topics := reqDetails["Payload"].(map[string]interface{})["Topics"].([]interface{})
 		for _, topic := range topics {
 			summary += fmt.Sprintf("%s, ", topic.(map[string]interface{})["Name"].(string))
 		}

tap/extensions/redis/read.go

@@ -296,28 +296,12 @@ func (p *RedisProtocol) Read() (packet *RedisPacket, err error) {
 	switch x.(type) {
 	case []interface{}:
 		array := x.([]interface{})
-		switch array[0].(type) {
-		case []uint8:
-			packet.Command = RedisCommand(strings.ToUpper(string(array[0].([]uint8))))
-			if len(array) > 1 {
-				packet.Key = string(array[1].([]uint8))
-			}
-			if len(array) > 2 {
-				packet.Value = string(array[2].([]uint8))
-			}
-			if len(array) > 3 {
-				packet.Value = fmt.Sprintf("[%s", packet.Value)
-				for _, item := range array[3:] {
-					packet.Value = fmt.Sprintf("%s, %s", packet.Value, item.([]uint8))
-				}
-				packet.Value = strings.TrimSuffix(packet.Value, ", ")
-				packet.Value = fmt.Sprintf("%s]", packet.Value)
-			}
-		default:
-			msg := fmt.Sprintf("Unrecognized element in Redis array: %v\n", reflect.TypeOf(array[0]))
-			log.Printf(msg)
-			err = errors.New(msg)
-			return
+		packet.Command = RedisCommand(strings.ToUpper(string(array[0].([]uint8))))
+		if len(array) > 1 {
+			packet.Key = string(array[1].([]uint8))
+		}
+		if len(array) > 2 {
+			packet.Value = string(array[2].([]uint8))
 		}
 	case []uint8:
 		val := string(x.([]uint8))
@@ -332,8 +316,6 @@ func (p *RedisProtocol) Read() (packet *RedisPacket, err error) {
 		}
 	case string:
 		packet.Value = x.(string)
-	case int64:
-		packet.Value = fmt.Sprintf("%d", x.(int64))
 	default:
 		msg := fmt.Sprintf("Unrecognized Redis data type: %v\n", reflect.TypeOf(x))
 		log.Printf(msg)

ui/src/components/EntryDetailed/EntryViewer.tsx

@@ -36,8 +36,14 @@ const SectionsRepresentation: React.FC<any> = ({data, color}) => {
 const AutoRepresentation: React.FC<any> = ({representation, isRulesEnabled, rulesMatched, elapsedTime, color}) => {
     var TABS = [
         {
-            tab: 'Request'
-        }
+            tab: 'request'
+        },
+        {
+            tab: 'response',
+        },
+        {
+            tab: 'Rules',
+        },
     ];
     const [currentTab, setCurrentTab] = useState(TABS[0].tab);
 
@@ -48,25 +54,12 @@ const AutoRepresentation: React.FC<any> = ({representation, isRulesEnabled, rule
 
     const {request, response} = JSON.parse(representation);
 
-    var responseTabIndex = 0;
-    var rulesTabIndex = 0;
-
-    if (response) {
-        TABS.push(
-            {
-                tab: 'Response',
-            }
-        );
-        responseTabIndex = TABS.length - 1;
+    if (!response) {
+        TABS[1]['hidden'] = true;
     }
 
-    if (isRulesEnabled) {
-        TABS.push(
-            {
-                tab: 'Rules',
-            }
-        );
-        rulesTabIndex = TABS.length - 1;
+    if (!isRulesEnabled) {
+        TABS.pop()
     }
 
     return <div className={styles.Entry}>
@@ -78,10 +71,10 @@ const AutoRepresentation: React.FC<any> = ({representation, isRulesEnabled, rule
             {currentTab === TABS[0].tab && <React.Fragment>
                 <SectionsRepresentation data={request} color={color}/>
             </React.Fragment>}
-            {response && currentTab === TABS[responseTabIndex].tab && <React.Fragment>
+            {response && currentTab === TABS[1].tab && <React.Fragment>
                 <SectionsRepresentation data={response} color={color}/>
             </React.Fragment>}
-            {isRulesEnabled && currentTab === TABS[rulesTabIndex].tab && <React.Fragment>
+            {TABS.length > 2 && currentTab === TABS[2].tab && <React.Fragment>
                 <EntryTablePolicySection title={'Rule'} color={color} latency={elapsedTime} arrayToIterate={rulesMatched ? rulesMatched : []}/>
             </React.Fragment>}
         </div>}

ui/src/components/UI/Tabs.tsx

@@ -5,6 +5,7 @@ import variables from '../../variables.module.scss';
 
 interface Tab {
     tab: string,
+    hidden?: boolean,
     disabled?: boolean,
     disabledMessage?: string,
     highlight?: boolean,
@@ -65,8 +66,7 @@ const useTabsStyles = makeStyles((theme) => ({
         borderRight: "1px solid " + theme.palette.primary.dark,
         height: 20,
         verticalAlign: 'middle',
-        margin: '0 20px',
-        cursor: 'unset',
+        margin: '0 20px'
     }
 
 }));
@@ -75,7 +75,7 @@ const useTabsStyles = makeStyles((theme) => ({
 const Tabs: React.FC<Props> = ({classes={}, tabs, currentTab, color, onChange, leftAligned, dark}) => {
     const _classes = {...useTabsStyles(), ...classes};
     return <div className={`${_classes.root} ${leftAligned ? _classes.tabsAlignLeft : ''}`}>
-        {tabs.map(({tab, disabled, disabledMessage, highlight, badge}, index) => {
+        {tabs.filter((tab) => !tab.hidden).map(({tab, disabled, disabledMessage, highlight, badge}, index) => {
             const active = currentTab === tab;
             const tabLink = <span
                 key={tab}