Support upload files only and support prompt config

action.yml

@@ -21,6 +21,9 @@ inputs:
   dist:
     description: 'specify dist of the local directory'
     required: true
+  saveroot:
+    description: 'specify remote path for the files'
+    required: false
 
 runs:
   using: 'docker'

cmd/main.go

@@ -4,71 +4,22 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"strings"
 	"time"
 
 	"github.com/urfave/cli"
 
-	"uptoc/core"
+	"uptoc/config"
+	"uptoc/engine"
 	"uptoc/uploader"
 )
 
-const (
-	// uploader flags
-	uploaderFlagDriver    = "driver"
-	uploaderFlagRegion    = "region"
-	uploaderFlagAccessKey = "access_key"
-	uploaderFlagSecretKey = "access_secret"
-	uploaderFlagBucket    = "bucket"
-	uploaderFlagExclude   = "exclude"
-
-	// uploader environments
-	uploaderEnvAccessKey = "UPTOC_UPLOADER_AK"
-	uploaderEnvSecretKey = "UPTOC_UPLOADER_SK"
-)
-
 var (
 	// RELEASE returns the release version
 	release = "unknown"
 	// REPO returns the git repository URL
 	repo = "unknown"
 	// COMMIT returns the short sha from git
 	commit = "unknown"
-
-	flags = []cli.Flag{
-		cli.StringFlag{
-			Name:  uploaderFlagDriver,
-			Usage: "specify cloud storage engine",
-			Value: "oss",
-		},
-		cli.StringFlag{
-			Name:     uploaderFlagRegion,
-			Usage:    "specify region of the cloud platform",
-			Required: true,
-		},
-		cli.StringFlag{
-			Name:     uploaderFlagAccessKey,
-			Usage:    "specify key id of the cloud platform",
-			EnvVar:   uploaderEnvAccessKey,
-			Required: true,
-		},
-		cli.StringFlag{
-			Name:     uploaderFlagSecretKey,
-			Usage:    "specify key secret of the cloud platform",
-			EnvVar:   uploaderEnvSecretKey,
-			Required: true,
-		},
-		cli.StringFlag{
-			Name:     uploaderFlagBucket,
-			Usage:    "specify bucket name of the cloud platform",
-			Required: true,
-		},
-		cli.StringFlag{
-			Name:     uploaderFlagExclude,
-			Usage:    "specify exclude the given comma separated directories (example: --exclude=.cache,test)",
-			Required: false,
-		},
-	}
 )
 
 func main() {
@@ -78,42 +29,42 @@ func main() {
 	app.Copyright = "(c) 2019 saltbo.cn"
 	app.Compiled = time.Now()
 	app.Version = fmt.Sprintf("release: %s, repo: %s, commit: %s", release, repo, commit)
-	app.Flags = flags
-	app.Action = action
+	app.Commands = cli.Commands{
+		cli.Command{
+			Name:   "config",
+			Usage:  "config set up the engine for the bucket.",
+			Action: configAction,
+		},
+	}
+	app.Flags = config.Flags
+	app.Action = appAction
 	if err := app.Run(os.Args); err != nil {
 		log.Fatal(err)
 	}
 }
 
-func action(c *cli.Context) {
-	var excludePaths []string
-	ak := c.String(uploaderFlagAccessKey)
-	sk := c.String(uploaderFlagSecretKey)
-	driver := c.String(uploaderFlagDriver)
-	region := c.String(uploaderFlagRegion)
-	bucket := c.String(uploaderFlagBucket)
-	exclude := c.String(uploaderFlagExclude)
-	if exclude != "" {
-		excludePaths = strings.Split(exclude, ",")
+func configAction(ctx *cli.Context) {
+	c, err := config.ParseFromRC()
+	if err != nil {
+		log.Fatalln(err)
 	}
 
-	dirPath := c.Args().First()
-	log.Printf("driver: %s\n", driver)
-	log.Printf("region: %s\n", region)
-	log.Printf("bucket: %s\n", bucket)
-	log.Printf("exclude: %s\n", excludePaths)
-	log.Printf("dirPath: %s\n", dirPath)
-	uploadDriver, err := uploader.New(driver, region, ak, sk, bucket)
-	if err != nil {
+	if err := c.Prompt(); err != nil {
 		log.Fatalln(err)
 	}
+}
 
-	e := core.NewEngine(uploadDriver)
-	if err := e.LoadAndCompareObjects(dirPath, excludePaths...); err != nil {
+func appAction(ctx *cli.Context) {
+	conf, err := config.Parse(ctx)
+	if err != nil {
 		log.Fatalln(err)
 	}
 
-	if err := e.Sync(); err != nil {
+	ud, err := uploader.New(conf.Driver)
+	if err != nil {
 		log.Fatalln(err)
 	}
+
+	e := engine.New(conf.Core, ud)
+	e.TailRun(ctx.Args()...)
 }

config/config.go

@@ -0,0 +1,121 @@
+package config
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/manifoldco/promptui"
+	"github.com/urfave/cli"
+	"gopkg.in/yaml.v2"
+
+	"uptoc/engine"
+	"uptoc/uploader"
+)
+
+// Config provides yml configuration.
+type Config struct {
+	f *os.File
+
+	Core   engine.Config   `yaml:"core"`
+	Driver uploader.Config `yaml:"driver"`
+}
+
+// Parse returns Config from RC file if no flags and
+// returns Config from flags if any flags exist.
+func Parse(ctx *cli.Context) (*Config, error) {
+	if ctx.NumFlags() > 0 {
+		c := &Config{
+			Core: engine.Config{
+				SaveRoot:  ctx.String(uploaderFlagSaveRoot),
+				ForceSync: true,
+			},
+			Driver: uploader.Config{
+				Name:      ctx.String(uploaderFlagDriver),
+				Region:    ctx.String(uploaderFlagRegion),
+				Bucket:    ctx.String(uploaderFlagBucket),
+				AccessKey: ctx.String(uploaderFlagAccessKey),
+				SecretKey: ctx.String(uploaderFlagSecretKey),
+			},
+		}
+		exclude := ctx.String(uploaderFlagExclude)
+		if exclude != "" {
+			c.Core.Excludes = strings.Split(exclude, ",")
+		}
+
+		return c, nil
+	}
+
+	return ParseFromRC()
+}
+
+// ParseFromRC returns Config from rc file
+func ParseFromRC() (*Config, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return nil, err
+	}
+
+	rcPath := filepath.Join(homeDir, ".uptocrc")
+	f, err := os.OpenFile(rcPath, os.O_CREATE|os.O_RDWR, 0644)
+	if os.IsNotExist(err) {
+		return nil, fmt.Errorf("please setup your config by run `uptoc config`")
+	} else if err != nil {
+		return nil, fmt.Errorf("open .uptocrc failed: %s", err)
+	}
+
+	c := &Config{f: f}
+	yd := yaml.NewDecoder(f)
+	if err := yd.Decode(c); err != nil {
+		return nil, err
+	}
+
+	if strings.HasPrefix(c.Core.SaveRoot, "/") {
+		c.Core.SaveRoot = c.Core.SaveRoot[1:]
+	}
+
+	if !strings.HasSuffix(c.Core.VisitHost, "/") {
+		c.Core.VisitHost += "/"
+	}
+
+	return c, nil
+}
+
+// Prompt implement a prompt for the config
+func (c *Config) Prompt() error {
+	prompts := []struct {
+		label    string
+		value    *string
+		mask     rune
+		validate promptui.ValidateFunc
+	}{
+		{label: uploaderFlagDriver, value: &c.Driver.Name, validate: uploader.DriverValidate},
+		{label: uploaderFlagRegion, value: &c.Driver.Region},
+		{label: uploaderFlagBucket, value: &c.Driver.Bucket},
+		{label: uploaderFlagAccessKey, value: &c.Driver.AccessKey},
+		{label: uploaderFlagSecretKey, value: &c.Driver.SecretKey, mask: '*'},
+		{label: uploaderFlagSaveRoot, value: &c.Core.SaveRoot},
+	}
+
+	for _, prompt := range prompts {
+		pp := promptui.Prompt{
+			Label:    prompt.label,
+			Default:  *prompt.value,
+			Validate: prompt.validate,
+			Mask:     prompt.mask,
+		}
+
+		value, err := pp.Run()
+		if err != nil {
+			return err
+		}
+
+		*prompt.value = value
+	}
+
+	defer c.f.Close()
+	c.f.Seek(0, io.SeekStart)
+	return yaml.NewEncoder(c.f).Encode(c)
+}

config/flags.go

@@ -0,0 +1,53 @@
+package config
+
+import "github.com/urfave/cli"
+
+const (
+	// uploader flags
+	uploaderFlagDriver    = "driver"
+	uploaderFlagRegion    = "region"
+	uploaderFlagAccessKey = "access_key"
+	uploaderFlagSecretKey = "secret_key"
+	uploaderFlagBucket    = "bucket"
+	uploaderFlagExclude   = "exclude"
+	uploaderFlagSaveRoot  = "save_root"
+
+	// uploader environments
+	uploaderEnvAccessKey = "UPTOC_UPLOADER_AK"
+	uploaderEnvSecretKey = "UPTOC_UPLOADER_SK"
+)
+
+// Flags defined the support flags for the cli
+var Flags = []cli.Flag{
+	cli.StringFlag{
+		Name:  uploaderFlagDriver,
+		Usage: "specify cloud storage engine",
+		Value: "oss",
+	},
+	cli.StringFlag{
+		Name:  uploaderFlagRegion,
+		Usage: "specify region of the cloud platform",
+	},
+	cli.StringFlag{
+		Name:  uploaderFlagBucket,
+		Usage: "specify bucket name of the cloud platform",
+	},
+	cli.StringFlag{
+		Name:   uploaderFlagAccessKey,
+		Usage:  "specify key id of the cloud platform",
+		EnvVar: uploaderEnvAccessKey,
+	},
+	cli.StringFlag{
+		Name:   uploaderFlagSecretKey,
+		Usage:  "specify key secret of the cloud platform",
+		EnvVar: uploaderEnvSecretKey,
+	},
+	cli.StringFlag{
+		Name:  uploaderFlagExclude,
+		Usage: "specify exclude the given comma separated directories (example: --exclude=.cache,test)",
+	},
+	cli.StringFlag{
+		Name:  uploaderFlagSaveRoot,
+		Usage: "specify remote directory, default is root",
+	},
+}