refactor server command (#206)

cmd/chatlog/cmd_decrypt.go

@@ -2,7 +2,6 @@ package chatlog
 
 import (
 	"fmt"
-	"runtime"
 
 	"github.com/sjzar/chatlog/internal/chatlog"
 
@@ -12,34 +11,53 @@ import (
 
 func init() {
 	rootCmd.AddCommand(decryptCmd)
-	decryptCmd.Flags().StringVarP(&dataDir, "data-dir", "d", "", "data dir")
-	decryptCmd.Flags().StringVarP(&workDir, "work-dir", "w", "", "work dir")
-	decryptCmd.Flags().StringVarP(&key, "key", "k", "", "key")
-	decryptCmd.Flags().StringVarP(&decryptPlatform, "platform", "p", runtime.GOOS, "platform")
-	decryptCmd.Flags().IntVarP(&decryptVer, "version", "v", 3, "version")
+	decryptCmd.Flags().StringVarP(&decryptPlatform, "platform", "p", "", "platform")
+	decryptCmd.Flags().IntVarP(&decryptVer, "version", "v", 0, "version")
+	decryptCmd.Flags().StringVarP(&decryptDataDir, "data-dir", "d", "", "data dir")
+	decryptCmd.Flags().StringVarP(&decryptDatakey, "data-key", "k", "", "data key")
+	decryptCmd.Flags().StringVarP(&decryptWorkDir, "work-dir", "w", "", "work dir")
 }
 
 var (
-	dataDir         string
-	workDir         string
-	key             string
 	decryptPlatform string
 	decryptVer      int
+	decryptDataDir  string
+	decryptDatakey  string
+	decryptWorkDir  string
 )
 
 var decryptCmd = &cobra.Command{
 	Use:   "decrypt",
 	Short: "decrypt",
 	Run: func(cmd *cobra.Command, args []string) {
-		m, err := chatlog.New("")
-		if err != nil {
-			log.Err(err).Msg("failed to create chatlog instance")
-			return
-		}
-		if err := m.CommandDecrypt(dataDir, workDir, key, decryptPlatform, decryptVer); err != nil {
+
+		cmdConf := getDecryptConfig()
+
+		m := chatlog.New()
+		if err := m.CommandDecrypt("", cmdConf); err != nil {
 			log.Err(err).Msg("failed to decrypt")
 			return
 		}
 		fmt.Println("decrypt success")
 	},
 }
+
+func getDecryptConfig() map[string]any {
+	cmdConf := make(map[string]any)
+	if len(decryptDataDir) != 0 {
+		cmdConf["data_dir"] = decryptDataDir
+	}
+	if len(decryptDatakey) != 0 {
+		cmdConf["data_key"] = serverDataKey
+	}
+	if len(decryptWorkDir) != 0 {
+		cmdConf["work_dir"] = decryptWorkDir
+	}
+	if len(decryptPlatform) != 0 {
+		cmdConf["platform"] = decryptPlatform
+	}
+	if decryptVer != 0 {
+		cmdConf["version"] = decryptVer
+	}
+	return cmdConf
+}

cmd/chatlog/cmd_key.go

@@ -11,20 +11,22 @@ import (
 
 func init() {
 	rootCmd.AddCommand(keyCmd)
-	keyCmd.Flags().IntVarP(&pid, "pid", "p", 0, "pid")
+	keyCmd.Flags().IntVarP(&keyPID, "pid", "p", 0, "pid")
+	keyCmd.Flags().BoolVarP(&keyForce, "force", "f", false, "force")
+	keyCmd.Flags().BoolVarP(&keyShowXorKey, "xor-key", "x", false, "show xor key")
 }
 
-var pid int
+var (
+	keyPID        int
+	keyForce      bool
+	keyShowXorKey bool
+)
 var keyCmd = &cobra.Command{
 	Use:   "key",
 	Short: "key",
 	Run: func(cmd *cobra.Command, args []string) {
-		m, err := chatlog.New("")
-		if err != nil {
-			log.Err(err).Msg("failed to create chatlog instance")
-			return
-		}
-		ret, err := m.CommandKey(pid)
+		m := chatlog.New()
+		ret, err := m.CommandKey("", keyPID, keyForce, keyShowXorKey)
 		if err != nil {
 			log.Err(err).Msg("failed to get key")
 			return

cmd/chatlog/cmd_server.go

@@ -1,43 +1,76 @@
 package chatlog
 
 import (
-	"runtime"
-
-	"github.com/sjzar/chatlog/internal/chatlog"
-
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
+
+	"github.com/sjzar/chatlog/internal/chatlog"
 )
 
 func init() {
 	rootCmd.AddCommand(serverCmd)
-	serverCmd.Flags().StringVarP(&serverAddr, "addr", "a", "127.0.0.1:5030", "server address")
+	serverCmd.Flags().StringVarP(&serverAddr, "addr", "a", "", "server address")
+	serverCmd.Flags().StringVarP(&serverPlatform, "platform", "p", "", "platform")
+	serverCmd.Flags().IntVarP(&serverVer, "version", "v", 0, "version")
 	serverCmd.Flags().StringVarP(&serverDataDir, "data-dir", "d", "", "data dir")
+	serverCmd.Flags().StringVarP(&serverDataKey, "data-key", "k", "", "data key")
+	serverCmd.Flags().StringVarP(&serverImgKey, "img-key", "i", "", "img key")
 	serverCmd.Flags().StringVarP(&serverWorkDir, "work-dir", "w", "", "work dir")
-	serverCmd.Flags().StringVarP(&serverPlatform, "platform", "p", runtime.GOOS, "platform")
-	serverCmd.Flags().IntVarP(&serverVer, "version", "v", 3, "version")
+	serverCmd.Flags().BoolVarP(&serverAutoDecrypt, "auto-decrypt", "", false, "auto decrypt")
 }
 
 var (
-	serverAddr     string
-	serverDataDir  string
-	serverWorkDir  string
-	serverPlatform string
-	serverVer      int
+	serverAddr        string
+	serverDataDir     string
+	serverDataKey     string
+	serverImgKey      string
+	serverWorkDir     string
+	serverPlatform    string
+	serverVer         int
+	serverAutoDecrypt bool
 )
 
 var serverCmd = &cobra.Command{
 	Use:   "server",
 	Short: "Start HTTP server",
 	Run: func(cmd *cobra.Command, args []string) {
-		m, err := chatlog.New("")
-		if err != nil {
-			log.Err(err).Msg("failed to create chatlog instance")
-			return
-		}
-		if err := m.CommandHTTPServer(serverAddr, serverDataDir, serverWorkDir, serverPlatform, serverVer); err != nil {
+
+		cmdConf := getServerConfig()
+		log.Info().Msgf("server cmd config: %+v", cmdConf)
+
+		m := chatlog.New()
+		if err := m.CommandHTTPServer("", cmdConf); err != nil {
 			log.Err(err).Msg("failed to start server")
 			return
 		}
 	},
 }
+
+func getServerConfig() map[string]any {
+	cmdConf := make(map[string]any)
+	if len(serverAddr) != 0 {
+		cmdConf["http_addr"] = serverAddr
+	}
+	if len(serverDataDir) != 0 {
+		cmdConf["data_dir"] = serverDataDir
+	}
+	if len(serverDataKey) != 0 {
+		cmdConf["data_key"] = serverDataKey
+	}
+	if len(serverImgKey) != 0 {
+		cmdConf["img_key"] = serverImgKey
+	}
+	if len(serverWorkDir) != 0 {
+		cmdConf["work_dir"] = serverWorkDir
+	}
+	if len(serverPlatform) != 0 {
+		cmdConf["platform"] = serverPlatform
+	}
+	if serverVer != 0 {
+		cmdConf["version"] = serverVer
+	}
+	if serverAutoDecrypt {
+		cmdConf["auto_decrypt"] = true
+	}
+	return cmdConf
+}

cmd/chatlog/root.go

@@ -35,14 +35,8 @@ var rootCmd = &cobra.Command{
 }
 
 func Root(cmd *cobra.Command, args []string) {
-
-	m, err := chatlog.New("")
-	if err != nil {
-		log.Err(err).Msg("failed to create chatlog instance")
-		return
-	}
-
-	if err := m.Run(); err != nil {
+	m := chatlog.New()
+	if err := m.Run(""); err != nil {
 		log.Err(err).Msg("failed to run chatlog instance")
 	}
 }