make controller configable with file

deploy/controller-config.yaml

@@ -0,0 +1,9 @@
+logLevel: debug
+server:
+  httpPort: 10264
+  agentPort: 10263
+controller:
+  database:
+    type: sqlite3
+  diagnose: {}
+

deploy/skoopbundle.yaml

@@ -564,6 +564,23 @@ subjects:
   name: default
   namespace: kubeskoop
 ---
+apiVersion: v1
+data:
+  controller.yaml: |-
+    logLevel: debug
+    server:
+      httpPort: 10264
+      agentPort: 10263
+    controller:
+      prometheus: http://prometheus-service
+      database:
+        type: sqlite3
+      diagnose: {}
+kind: ConfigMap
+metadata:
+  name: kubeskoop-controller-config
+  namespace: kubeskoop
+---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -585,16 +602,19 @@ spec:
         image: kubeskoop/kubeskoop:v1.0.0
         command: ["/bin/controller"]
         env:
-          - name: PROMETHEUS_ENDPOINT
-            value: http://prometheus-service
           - name: LOKI_ENDPOINT
             value: http://loki-service:3100
         volumeMounts:
-          - name:  db
+          - name:  lib
             mountPath: /var/lib/kubeskoop
+          - name: config
+            mountPath: /etc/kubeskoop
       volumes:
-      - name: db
+      - name: lib
         emptyDir: {}
+      - name: config
+        configMap:
+          name: kubeskoop-controller-config
 ---
 apiVersion: v1
 kind: Service

go.mod

@@ -16,6 +16,7 @@ require (
 	github.com/docker/docker v20.10.22+incompatible
 	github.com/fsnotify/fsnotify v1.6.0
 	github.com/gin-gonic/gin v1.9.1
+	github.com/go-sql-driver/mysql v1.6.0
 	github.com/golang/snappy v0.0.4
 	github.com/google/gops v0.3.26
 	github.com/gorilla/mux v1.8.0

pkg/controller/cmd/config.go

@@ -2,23 +2,22 @@ package cmd
 
 import (
 	"fmt"
-	"github.com/alibaba/kubeskoop/pkg/controller/db"
-	"github.com/alibaba/kubeskoop/pkg/controller/diagnose"
-	"gopkg.in/yaml.v3"
 	"os"
+
+	"github.com/alibaba/kubeskoop/pkg/controller/service"
+	"gopkg.in/yaml.v3"
 )
 
 type ServerConfig struct {
 	AgentPort  int    `yaml:"agentPort"`
-	HttpPort   int    `yaml:"httpPort"`
+	HTTPPort   int    `yaml:"httpPort"`
 	KubeConfig string `yaml:"kubeConfig"`
 }
 
 type Config struct {
-	LogLevel string          `yaml:"logLevel"`
-	Server   ServerConfig    `yaml:"server"`
-	DB       db.Config       `yaml:"database"`
-	Diagnose diagnose.Config `yaml:"diagnose"`
+	LogLevel   string         `yaml:"logLevel"`
+	Server     ServerConfig   `yaml:"server"`
+	Controller service.Config `yaml:"controller"`
 }
 
 func loadConfig(path string) (*Config, error) {

pkg/controller/cmd/root.go

@@ -2,9 +2,10 @@ package cmd
 
 import (
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"os"
 
+	log "github.com/sirupsen/logrus"
+
 	"github.com/spf13/cobra"
 )
 
@@ -39,14 +40,14 @@ var (
 			if agentPort > 0 {
 				config.Server.AgentPort = agentPort
 			}
-			if config.Server.HttpPort == 0 {
-				config.Server.HttpPort = defaultHTTPPort
+			if config.Server.HTTPPort == 0 {
+				config.Server.HTTPPort = defaultHTTPPort
 			}
 			if httpPort > 0 {
-				config.Server.HttpPort = httpPort
+				config.Server.HTTPPort = httpPort
 			}
 
-			NewServer().Run(config.Server.AgentPort, config.Server.HttpPort)
+			NewServer(config).Run()
 			return nil
 		},
 	}

pkg/controller/cmd/server.go

@@ -30,23 +30,25 @@ const (
 )
 
 type Server struct {
+	config     ServerConfig
 	controller service.ControllerService
 }
 
-func NewServer() *Server {
-	ctrlSVC, err := service.NewControllerService()
+func NewServer(config *Config) *Server {
+	ctrlSVC, err := service.NewControllerService(&config.Controller)
 	if err != nil {
 		log.Fatalf("error create controller service: %v", err)
 	}
 	return &Server{
+		config:     config.Server,
 		controller: ctrlSVC,
 	}
 }
 
-func (s *Server) Run(agentPort int, httpPort int) {
+func (s *Server) Run() {
 	done := make(chan struct{})
-	go s.RunAgentServer(agentPort, done)
-	go s.RunHTTPServer(httpPort, done)
+	go s.RunAgentServer(s.config.AgentPort, done)
+	go s.RunHTTPServer(s.config.HTTPPort, done)
 	go s.controller.Run(done)
 
 	signals := make(chan os.Signal, 1)

pkg/controller/db/db.go

@@ -20,8 +20,9 @@ var (
 type Driver func(config *Config) (ddl string, db *sqlx.DB, err error)
 
 var drivers = map[string]Driver{
-	"sqlite": newSQLite3,
-	"mysql":  newMySQL,
+	"sqlite":  newSQLite3,
+	"sqlite3": newSQLite3,
+	"mysql":   newMySQL,
 }
 
 func InitializeDB(config *Config) error {

pkg/controller/db/mysql.ddl

@@ -1,10 +1,11 @@
-create table if not exists tasks
+create table if not exists `tasks`
 (
-    id          integer primary key autoincrement,
-    config      text        not null,
-    start_time  timestamp default now(),
-    finish_time timestamp default null,
-    status      varchar(16) not null,
-    result      text      default null,
-    message     varchar(4096)
-    );
+    `id`          integer AUTO_INCREMENT,
+    `config`      text        not null,
+    `start_time`  timestamp default now(),
+    `finish_time` timestamp null default null,
+    `status`      varchar(16) not null,
+    `result`      text      default null,
+    `message`     varchar(4096),
+    PRIMARY KEY(`id`)
+);

pkg/controller/db/mysql.go

@@ -3,8 +3,10 @@ package db
 import (
 	_ "embed"
 	"fmt"
+
 	"github.com/go-sql-driver/mysql"
 	"github.com/jmoiron/sqlx"
+	log "github.com/sirupsen/logrus"
 )
 
 //go:embed mysql.ddl
@@ -16,11 +18,13 @@ func newMySQL(config *Config) (string, *sqlx.DB, error) {
 	cfg.User = config.Username
 	cfg.Passwd = config.Password
 	cfg.DBName = config.DBName
+	cfg.Net = "tcp"
 	dsn := cfg.FormatDSN()
+	log.Infof("addr %s, dsn: %s", cfg.Addr, dsn)
 	db, err := sqlx.Open("mysql", dsn)
 	if err != nil {
 		return "", nil, fmt.Errorf("failed config mysql: %w", err)
 	}
 
-	return "", db, nil
+	return mysqlDDL, db, nil
 }

pkg/controller/db/sqlite.ddl

@@ -1,10 +1,10 @@
-create table if not exists tasks
+create table if not exists `tasks`
 (
-    id          integer primary key autoincrement,
-    config      text        not null,
-    start_time  timestamp default current_timestamp,
-    finish_time timestamp default null,
-    status      varchar(16) not null,
-    result      text      default null,
-    message     varchar(4096)
+    `id`          integer primary key autoincrement,
+    `config`      text        not null,
+    `start_time`  timestamp default current_timestamp,
+    `finish_time` timestamp default null,
+    `status`      varchar(16) not null,
+    `result`      text      default null,
+    `message`     varchar(4096)
 );

pkg/controller/db/sqlite.go

@@ -2,7 +2,11 @@ package db
 
 import (
 	_ "embed"
+	"errors"
 	"fmt"
+	"os"
+	"path/filepath"
+
 	"github.com/jmoiron/sqlx"
 )
 
@@ -17,10 +21,22 @@ func newSQLite3(config *Config) (string, *sqlx.DB, error) {
 		path = defaultSQLitePath
 	}
 
+	if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
+		dir := filepath.Dir(path)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return "", nil, fmt.Errorf("failed open sqlite db on path %s: %w", path, err)
+		}
+		f, err := os.Create(path)
+		if err != nil {
+			return "", nil, fmt.Errorf("failed open sqlite db on path %s: %w", path, err)
+		}
+		f.Close()
+	}
+
 	var err error
 	db, err = sqlx.Connect("sqlite3", path)
 	if err != nil {
-		return "", nil, fmt.Errorf("failed open sqlite db on path %s, err: %v", path, err)
+		return "", nil, fmt.Errorf("failed open sqlite db on path %s: %w", path, err)
 	}
 
 	return sqliteDDL, db, nil

pkg/controller/diagnose/diagnose.go

@@ -11,25 +11,29 @@ import (
 	skoopContext "github.com/alibaba/kubeskoop/pkg/skoop/context"
 )
 
+type Config struct {
+	KubeConfig    string `yaml:"kubeConfig"`
+	CloudProvider string `yaml:"cloudProvider"`
+	NetworkPlugin string `yaml:"networkPlugin"`
+	ProxyModel    string `yaml:"proxyModel"`
+	ClusterCidr   string `yaml:"clusterCidr"`
+}
+
 type Controller interface {
 	Diagnose(ctx context.Context, taskConfig *skoopContext.TaskConfig) (string, error)
 }
 
-func NewDiagnoseController(namespace string) Controller {
-	var diagnoseArgs []string
-	if diagnoseArgsFromEnv, ok := os.LookupEnv("KUBESKOOP_DIAGNOSE_ARGS"); ok {
-		diagnoseArgs = strings.Split(diagnoseArgsFromEnv, " ")
-	}
+func NewDiagnoseController(namespace string, config *Config) Controller {
 	// 1. build skoop global context
 	return &Diagnostor{
-		namespace:    namespace,
-		diagnoseArgs: diagnoseArgs,
+		namespace: namespace,
+		config:    config,
 	}
 }
 
 type Diagnostor struct {
-	namespace    string
-	diagnoseArgs []string
+	namespace string
+	config    *Config
 }
 
 func (d *Diagnostor) Diagnose(ctx context.Context, taskConfig *skoopContext.TaskConfig) (string, error) {
@@ -47,8 +51,8 @@ func (d *Diagnostor) Diagnose(ctx context.Context, taskConfig *skoopContext.Task
 		"--protocol", taskConfig.Protocol,
 		"--collector-namespace", d.namespace,
 	}
-	if len(d.diagnoseArgs) != 0 {
-		args = append(args, d.diagnoseArgs...)
+	if d.config != nil {
+		args = append(args, buildArgsFromConfig(d.config))
 	}
 	cmd := exec.CommandContext(ctx, "skoop", args...)
 	output, err := cmd.CombinedOutput()
@@ -61,3 +65,21 @@ func (d *Diagnostor) Diagnose(ctx context.Context, taskConfig *skoopContext.Task
 	}
 	return string(diagnoseResult), nil
 }
+
+func buildArgsFromConfig(config *Config) string {
+	var args []string
+	m := map[string]string{
+		"--cloud-provider": config.CloudProvider,
+		"--network-plugin": config.NetworkPlugin,
+		"--proxy-mode":     config.ProxyModel,
+		"--cluster-cidr":   config.ClusterCidr,
+	}
+
+	for k, v := range m {
+		if v != "" {
+			args = append(args, k, v)
+		}
+	}
+
+	return strings.Join(args, " ")
+}