TiUP 源码初探

demo├── cmd│   └── root.go|   └── version.go├── go.mod├── go.sum└── main.go

// root.govar (  rootCmd *cobra.Command)
func init() {  rootCmd = &cobra.Command{    Use:   "demo",    Short: "Demo is a Cobra application",    Long:  `This is a demo application to illustrate the use of Cobra library.`,    Run: func(cmd *cobra.Command, args []string) {      fmt.Println("Hello, Cobra!")    },  }  rootCmd.AddCommand(newVersionCmd())}func Execute() {  if err := rootCmd.Execute(); err != nil {    fmt.Println(err)    os.Exit(1)  }}
// version.gofunc newVersionCmd() *cobra.Command {  cmd := &cobra.Command{    Use:   "version",    Short: "Print the version number of Demo",    Long:  `All software has versions. This is Demo's`,    Run: func(cmd *cobra.Command, args []string) {      fmt.Println("Demo v0.1 -- HEAD")    },  }  return cmd}
func init() {  rootCmd.AddCommand(versionCmd)}// main.gofunc main() {  cmd.Execute()}

> .\\demo.exe -hThis is a demo application to illustrate the use of Cobra library.
Usage:  demo [flags]  demo [command]
Available Commands:  completion  Generate the autocompletion script for the specified shell  help        Help about any command  version     Print the version number of Demo
Flags:  -h, --help   help for demo
Use "demo [command] --help" for more information about a command.

├── cmd│   ├── env.go│   ├── list.go│   ├── mirror.go│   ├── root.go   # 命令注册├── components  # 组件│   ├── bench│   ├── cluster   |   |   |── command|   |  │   ├── clean.go|   |  │   ├── deploy.go|   |  │   ├── root.go # cluster 命令注册|   |   |—— main.go│   └── playground├── pkg│   ├── cluster│   │   ├── ansible│   │   ├── api│   │   ├── audit│   │   ├── clusterutil│   │   ├── ctxt│   │   ├── executor   # 执行器，easyssh和nativessh│   │   ├── manager    # 任务的生成，步骤的生成所有的管理都在这里│   │   ├── module│   │   ├── operation│   │   ├── spec       # 拓扑结构--安装的说明书│   │   ├── task       # 各种任务│   │   └── template   # ├── main.go

// root.gofunc init() {  cobra.EnableCommandSorting = false  _ = os.Setenv(localdata.EnvNameTelemetryEventUUID, eventUUID)
  rootCmd = &cobra.Command{    Use: `tiup [flags] <command> [args...]`    // ...    },    PersistentPreRunE: func(cmd *cobra.Command, args []string) error {      // InitEnv      return nil    },    RunE: func(cmd *cobra.Command, args []string) error {      if len(args) == 0 {        return cmd.Help()      }      env := environment.GlobalEnv()      // ...      return tiupexec.RunComponent(env, tag, componentSpec, binPath, args)    },  }}

type (  // Task represents a operation while TiUP execution  Task interface {    fmt.Stringer    Execute(ctx context.Context) error    Rollback(ctx context.Context) error  }
  // Serial will execute a bundle of task in serialized way  Serial struct {    ignoreError       bool    hideDetailDisplay bool    inner             []Task  }
  // Parallel will execute a bundle of task in parallelism way  Parallel struct {    ignoreError       bool    hideDetailDisplay bool    inner             []Task  })

func (m *Mkdir) Execute(ctx context.Context) error { exec, found := ctxt.GetInner(ctx).GetExecutor(m.host)  // ...  _, _, err := exec.Execute(ctx, cmd, m.sudo) // use root to create the dir  if err != nil {    return errors.Trace(err)  }  // ...  return nil}
func (c *CopyComponent) Execute(ctx context.Context) error {  // ...  install := &InstallPackage{    srcPath: srcPath,    host:    c.host,    dstDir:  c.dstDir,  }  return install.Execute(ctx)}
func (c *InstallPackage) Execute(ctx context.Context) error {  // Install package to remote server  exec, found := ctxt.GetInner(ctx).GetExecutor(c.host)  if !found {    return ErrNoExecutor  }  dstDir := filepath.Join(c.dstDir, "bin")  dstPath := filepath.Join(dstDir, path.Base(c.srcPath))
  err := exec.Transfer(ctx, c.srcPath, dstPath, false, 0, false)  if err != nil {    return errors.Annotatef(err, "failed to scp %s to %s:%s", c.srcPath, c.host, dstPath)  }  cmd := fmt.Sprintf(`tar --no-same-owner -zxf %s -C %s && rm %s`, dstPath, dstDir, dstPath)
  _, stderr, err := exec.Execute(ctx, cmd, false)  if err != nil {    return errors.Annotatef(err, "stderr: %s", string(stderr))  }  return nil}

Executor interface {    Execute(ctx context.Context, cmd string, sudo bool, timeout ...time.Duration) (stdout []byte, stderr []byte, err error)    Transfer(ctx context.Context, src, dst string, download bool, limit int, compress bool) error  }
// Execute implements the Task interfacefunc (s *RootSSH) Execute(ctx context.Context) error {  // ...  e, err := executor.New(s.sshType, s.sudo, sc)  if err != nil {    return err  }
  ctxt.GetInner(ctx).SetExecutor(s.host, e)  return nil}

// Deploy a cluster.func (m *Manager) Deploy(  name string,  clusterVersion string,  topoFile string,  opt DeployOptions,  afterDeploy func(b *task.Builder, newPart spec.Topology, gOpt operator.Options),  skipConfirm bool,  gOpt operator.Options,) error

// command/root.gofunc init() {  rootCmd.AddCommand(    newCheckCmd(),    newDeploy(),    // ...    )}// command/deploy.gofunc newDeploy() *cobra.Command {  opt := manager.DeployOptions{    IdentityFile: path.Join(utils.UserHome(), ".ssh", "id_rsa"),  }  cmd := &cobra.Command{    Use:          "deploy <cluster-name> <version> <topology.yaml>",    Short:        "Deploy a cluster for production",    Long:         "Deploy a cluster for production. SSH connection will be used to deploy files, as well as creating system users for running the service.",    SilenceUsage: true,    RunE: func(cmd *cobra.Command, args []string) error {      // ...      return cm.Deploy(clusterName, version, topoFile, opt, postDeployHook, skipConfirm, gOpt)    },  }  // ...  cmd.Flags().BoolVarP(&opt.NoLabels, "no-labels", "", false, "Don't check TiKV labels")  return cmd}// manager/deploy.gofunc (m *Manager) Deploy(  name string,  clusterVersion string,  topoFile string,  opt DeployOptions,  afterDeploy func(b *task.Builder, newPart spec.Topology, gOpt operator.Options),  skipConfirm bool,  gOpt operator.Options,) error {// ...var (    envInitTasks      []*task.StepDisplay // tasks which are used to initialize environment    downloadCompTasks []*task.StepDisplay // tasks which are used to download components    deployCompTasks   []*task.StepDisplay // tasks which are used to copy components to remote host  )// ...     t := task.NewBuilder(m.logger).      RootSSH(        host,        hostInfo.ssh,        opt.User,        sshConnProps.Password,        // ...,      ).      EnvInit(host, globalOptions.User, globalOptions.Group, opt.SkipCreateUser || globalOptions.User == opt.User, sudo).      Mkdir(globalOptions.User, host, sudo, dirs...).      BuildAsStep(fmt.Sprintf("  - Prepare %s:%d", host, hostInfo.ssh))    envInitTasks = append(envInitTasks, t)  // ...  builder := task.NewBuilder(m.logger).    Step("+ Generate SSH keys",      task.NewBuilder(m.logger).        SSHKeyGen(m.specManager.Path(name, "ssh", "id_rsa")).        Build(),      m.logger).    ParallelStep("+ Download TiDB components", false, downloadCompTasks...).    ParallelStep("+ Initialize target host environments", false, envInitTasks...).    ParallelStep("+ Deploy TiDB instance", false, deployCompTasks...).    ParallelStep("+ Copy certificate to remote host", gOpt.Force, certificateTasks...).    ParallelStep("+ Init instance configs", gOpt.Force, refreshConfigTasks...).    ParallelStep("+ Init monitor configs", gOpt.Force, monitorConfigTasks...)    // ...    m.logger.Infof("Cluster `%s` deployed successfully, you can start it with command: `%s`", name, hint)  return nil}