func main() {
   cmd := newRootCmd()
   if err := cmd.Execute(); err != nil {
      os.Exit(1)
   }
}

func newRootCmd() *cobra.Command {
   cmd := &cobra.Command{
      Use:          "helm",
      Short:        "The Helm package manager for Kubernetes.",
      Long:         globalUsage,
      SilenceUsage: true,
      PersistentPreRun: func(cmd *cobra.Command, _ []string) {
         initRootFlags(cmd)
      },
      PersistentPostRun: func(*cobra.Command, []string) {
         teardown()
      },
   }
   addRootFlags(cmd)
   out := cmd.OutOrStdout()

   cmd.AddCommand(
      // chart commands
      newCreateCmd(out),
      newDependencyCmd(out),
      newFetchCmd(out),
      newInspectCmd(out),
      newLintCmd(out),
      newPackageCmd(out),
      newRepoCmd(out),
      newSearchCmd(out),
      newServeCmd(out),
      newVerifyCmd(out),

      // release commands
      addFlagsTLS(newDeleteCmd(nil, out)),
      addFlagsTLS(newGetCmd(nil, out)),
      addFlagsTLS(newHistoryCmd(nil, out)),
      addFlagsTLS(newInstallCmd(nil, out)),
      addFlagsTLS(newListCmd(nil, out)),
      addFlagsTLS(newRollbackCmd(nil, out)),
      addFlagsTLS(newStatusCmd(nil, out)),
      addFlagsTLS(newUpgradeCmd(nil, out)),

      addFlagsTLS(newReleaseTestCmd(nil, out)),
      addFlagsTLS(newResetCmd(nil, out)),
      addFlagsTLS(newVersionCmd(nil, out)),

      newCompletionCmd(out),
      newHomeCmd(out),
      newInitCmd(out),
      newPluginCmd(out),

      // Hidden documentation generator command: 'helm docs'
      newDocsCmd(out),

      // Deprecated
      markDeprecated(newRepoUpdateCmd(out), "use 'helm repo update'\n"),
   )

   // Find and add plugins
   loadPlugins(cmd, out)

   return cmd
}

func newInstallCmd(c helm.Interface, out io.Writer) *cobra.Command {
   inst := &installCmd{
      out:    out,
      client: c,
   }

   cmd := &cobra.Command{
      Use:     "install [CHART]",
      Short:   "install a chart archive",
      Long:    installDesc,
      PreRunE: setupConnection,
      RunE: func(cmd *cobra.Command, args []string) error {
         if err := checkArgsLength(len(args), "chart name"); err != nil {
            return err
         }

         debug("Original chart version: %q", inst.version)
         if inst.version == "" && inst.devel {
            debug("setting version to >0.0.0-a")
            inst.version = ">0.0.0-a"
         }

         cp, err := locateChartPath(inst.repoURL, args[0], inst.version, inst.verify, inst.keyring,
            inst.certFile, inst.keyFile, inst.caFile)
         if err != nil {
            return err
         }
         inst.chartPath = cp
         inst.client = ensureHelmClient(inst.client)
         return inst.run()
      },
   }

   f := cmd.Flags()
   f.VarP(&inst.valueFiles, "values", "f", "specify values in a YAML file (can specify multiple)")
   f.StringVarP(&inst.name, "name", "n", "", "release name. If unspecified, it will autogenerate one for you")
   f.StringVar(&inst.namespace, "namespace", "", "namespace to install the release into")
   f.BoolVar(&inst.dryRun, "dry-run", false, "simulate an install")
   f.BoolVar(&inst.disableHooks, "no-hooks", false, "prevent hooks from running during install")
   f.BoolVar(&inst.replace, "replace", false, "re-use the given name, even if that name is already used. This is unsafe in production")
   f.StringArrayVar(&inst.values, "set", []string{}, "set values on the command line (can specify multiple or separate values with commas: key1=val1,key2=val2)")
   f.StringVar(&inst.nameTemplate, "name-template", "", "specify template used to name the release")
   f.BoolVar(&inst.verify, "verify", false, "verify the package before installing it")
   f.StringVar(&inst.keyring, "keyring", defaultKeyring(), "location of public keys used for verification")
   f.StringVar(&inst.version, "version", "", "specify the exact chart version to install. If this is not specified, the latest version is installed")
   f.Int64Var(&inst.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)")
   f.BoolVar(&inst.wait, "wait", false, "if set, will wait until all Pods, PVCs, Services, and minimum number of Pods of a Deployment are in a ready state before marking the release as successful. It will wait for as long as --timeout")
   f.StringVar(&inst.repoURL, "repo", "", "chart repository url where to locate the requested chart")
   f.StringVar(&inst.certFile, "cert-file", "", "identify HTTPS client using this SSL certificate file")
   f.StringVar(&inst.keyFile, "key-file", "", "identify HTTPS client using this SSL key file")
   f.StringVar(&inst.caFile, "ca-file", "", "verify certificates of HTTPS-enabled servers using this CA bundle")
   f.BoolVar(&inst.devel, "devel", false, "use development versions, too. Equivalent to version '>0.0.0-a'. If --version is set, this is ignored.")

   return cmd
}

func (i *installCmd) run() error {
   debug("CHART PATH: %s\n", i.chartPath)

   if i.namespace == "" {
      i.namespace = defaultNamespace()
   }

   rawVals, err := vals(i.valueFiles, i.values)
   if err != nil {
      return err
   }

   // If template is specified, try to run the template.
   if i.nameTemplate != "" {
      i.name, err = generateName(i.nameTemplate)
      if err != nil {
         return err
      }
      // Print the final name so the user knows what the final name of the release is.
      fmt.Printf("FINAL NAME: %s\n", i.name)
   }

   // Check chart requirements to make sure all dependencies are present in /charts
   chartRequested, err := chartutil.Load(i.chartPath)
   if err != nil {
      return prettyError(err)
   }

   if req, err := chartutil.LoadRequirements(chartRequested); err == nil {
      // If checkDependencies returns an error, we have unfullfilled dependencies.
      // As of Helm 2.4.0, this is treated as a stopping condition:
      // https://github.com/kubernetes/helm/issues/2209
      if err := checkDependencies(chartRequested, req); err != nil {
         return prettyError(err)
      }
   } else if err != chartutil.ErrRequirementsNotFound {
      return fmt.Errorf("cannot load requirements: %v", err)
   }

   res, err := i.client.InstallReleaseFromChart(
      chartRequested,
      i.namespace,
      helm.ValueOverrides(rawVals),
      helm.ReleaseName(i.name),
      helm.InstallDryRun(i.dryRun),
      helm.InstallReuseName(i.replace),
      helm.InstallDisableHooks(i.disableHooks),
      helm.InstallTimeout(i.timeout),
      helm.InstallWait(i.wait))
   if err != nil {
      return prettyError(err)
   }

   rel := res.GetRelease()
   if rel == nil {
      return nil
   }
   i.printRelease(rel)

   // If this is a dry run, we can't display status.
   if i.dryRun {
      return nil
   }

   // Print the status like status command does
   status, err := i.client.ReleaseStatus(rel.Name)
   if err != nil {
      return prettyError(err)
   }
   PrintStatus(i.out, status)
   return nil
}

// InstallReleaseFromChart installs a new chart and returns the release response.
func (h *Client) InstallReleaseFromChart(chart *chart.Chart, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) {
   // apply the install options
   for _, opt := range opts {
      opt(&h.opts)
   }
   req := &h.opts.instReq
   req.Chart = chart
   req.Namespace = ns
   req.DryRun = h.opts.dryRun
   req.DisableHooks = h.opts.disableHooks
   req.ReuseName = h.opts.reuseName
   ctx := NewContext()

   if h.opts.before != nil {
      if err := h.opts.before(ctx, req); err != nil {
         return nil, err
      }
   }
   err := chartutil.ProcessRequirementsEnabled(req.Chart, req.Values)
   if err != nil {
      return nil, err
   }
   err = chartutil.ProcessRequirementsImportValues(req.Chart)
   if err != nil {
      return nil, err
   }

   return h.install(ctx, req)
}

// Executes tiller.InstallRelease RPC.
func (h *Client) install(ctx context.Context, req *rls.InstallReleaseRequest) (*rls.InstallReleaseResponse, error) {
   c, err := h.connect(ctx)
   if err != nil {
      return nil, err
   }
   defer c.Close()

   rlc := rls.NewReleaseServiceClient(c)
   return rlc.InstallRelease(ctx, req)
}

const (
   // tlsEnableEnvVar names the environment variable that enables TLS.
   tlsEnableEnvVar = "TILLER_TLS_ENABLE"
   // tlsVerifyEnvVar names the environment variable that enables
   // TLS, as well as certificate verification of the remote.
   tlsVerifyEnvVar = "TILLER_TLS_VERIFY"
   // tlsCertsEnvVar names the environment variable that points to
   // the directory where Tiller's TLS certificates are located.
   tlsCertsEnvVar = "TILLER_TLS_CERTS"

   storageMemory    = "memory"
   storageConfigMap = "configmap"

   probeAddr = ":44135"
   traceAddr = ":44136"
)

var (
   grpcAddr             = flag.String("listen", ":44134", "address:port to listen on")
   enableTracing        = flag.Bool("trace", false, "enable rpc tracing")
   store                = flag.String("storage", storageConfigMap, "storage driver to use. One of 'configmap' or 'memory'")
   remoteReleaseModules = flag.Bool("experimental-release", false, "enable experimental release modules")
   tlsEnable            = flag.Bool("tls", tlsEnableEnvVarDefault(), "enable TLS")
   tlsVerify            = flag.Bool("tls-verify", tlsVerifyEnvVarDefault(), "enable TLS and verify remote certificate")
   keyFile              = flag.String("tls-key", tlsDefaultsFromEnv("tls-key"), "path to TLS private key file")
   certFile             = flag.String("tls-cert", tlsDefaultsFromEnv("tls-cert"), "path to TLS certificate file")
   caCertFile           = flag.String("tls-ca-cert", tlsDefaultsFromEnv("tls-ca-cert"), "trust certificates signed by this CA")

   // rootServer is the root gRPC server.
   //
   // Each gRPC service registers itself to this server during init().
   rootServer *grpc.Server

   // env is the default environment.
   //
   // Any changes to env should be done before rootServer.Serve() is called.
   env = environment.New()

   logger *log.Logger
)

func main() {
   flag.Parse()

   if *enableTracing {
      log.SetFlags(log.Lshortfile)
   }
   logger = newLogger("main")

   start()
}

func start() {

   clientset, err := kube.New(nil).ClientSet()
   if err != nil {
      logger.Fatalf("Cannot initialize Kubernetes connection: %s", err)
   }

   switch *store {
   case storageMemory:
      env.Releases = storage.Init(driver.NewMemory())
   case storageConfigMap:
      cfgmaps := driver.NewConfigMaps(clientset.Core().ConfigMaps(namespace()))
      cfgmaps.Log = newLogger("storage/driver").Printf

      env.Releases = storage.Init(cfgmaps)
      env.Releases.Log = newLogger("storage").Printf
   }

   kubeClient := kube.New(nil)
   kubeClient.Log = newLogger("kube").Printf
   env.KubeClient = kubeClient

   if *tlsEnable || *tlsVerify {
      opts := tlsutil.Options{CertFile: *certFile, KeyFile: *keyFile}
      if *tlsVerify {
         opts.CaCertFile = *caCertFile
      }
   }

   var opts []grpc.ServerOption
   if *tlsEnable || *tlsVerify {
      cfg, err := tlsutil.ServerConfig(tlsOptions())
      if err != nil {
         logger.Fatalf("Could not create server TLS configuration: %v", err)
      }
      opts = append(opts, grpc.Creds(credentials.NewTLS(cfg)))
   }

   rootServer = tiller.NewServer(opts...)

   lstn, err := net.Listen("tcp", *grpcAddr)
   if err != nil {
      logger.Fatalf("Server died: %s", err)
   }

   logger.Printf("Starting Tiller %s (tls=%t)", version.GetVersion(), *tlsEnable || *tlsVerify)
   logger.Printf("GRPC listening on %s", *grpcAddr)
   logger.Printf("Probes listening on %s", probeAddr)
   logger.Printf("Storage driver is %s", env.Releases.Name())

   if *enableTracing {
      startTracing(traceAddr)
   }

   srvErrCh := make(chan error)
   probeErrCh := make(chan error)
   go func() {
      svc := tiller.NewReleaseServer(env, clientset, *remoteReleaseModules)
      svc.Log = newLogger("tiller").Printf
      services.RegisterReleaseServiceServer(rootServer, svc)
      if err := rootServer.Serve(lstn); err != nil {
         srvErrCh <- err
      }
   }()

   go func() {
      mux := newProbesMux()

      // Register gRPC server to prometheus to initialized matrix
      goprom.Register(rootServer)
      addPrometheusHandler(mux)

      if err := http.ListenAndServe(probeAddr, mux); err != nil {
         probeErrCh <- err
      }
   }()

   select {
   case err := <-srvErrCh:
      logger.Fatalf("Server died: %s", err)
   case err := <-probeErrCh:
      logger.Printf("Probes server died: %s", err)
   }
}

// ReleaseServer implements the server-side gRPC endpoint for the HAPI services.
type ReleaseServer struct {
   ReleaseModule
   env       *environment.Environment
   clientset internalclientset.Interface
   Log       func(string, ...interface{})
}

// NewReleaseServer creates a new release server.
func NewReleaseServer(env *environment.Environment, clientset internalclientset.Interface, useRemote bool) *ReleaseServer {
   var releaseModule ReleaseModule
   if useRemote {
      releaseModule = &RemoteReleaseModule{}
   } else {
      releaseModule = &LocalReleaseModule{
         clientset: clientset,
      }
   }

   return &ReleaseServer{
      env:           env,
      clientset:     clientset,
      ReleaseModule: releaseModule,
      Log:           func(_ string, _ ...interface{}) {},
   }
}

// InstallRelease installs a release and stores the release record.
func (s *ReleaseServer) InstallRelease(c ctx.Context, req *services.InstallReleaseRequest) (*services.InstallReleaseResponse, error) {
   s.Log("preparing install for %s", req.Name)
   rel, err := s.prepareRelease(req)
   if err != nil {
      s.Log("failed install prepare step: %s", err)
      res := &services.InstallReleaseResponse{Release: rel}

      // On dry run, append the manifest contents to a failed release. This is
      // a stop-gap until we can revisit an error backchannel post-2.0.
      if req.DryRun && strings.HasPrefix(err.Error(), "YAML parse error") {
         err = fmt.Errorf("%s\n%s", err, rel.Manifest)
      }
      return res, err
   }

   s.Log("performing install for %s", req.Name)
   res, err := s.performRelease(rel, req)
   if err != nil {
      s.Log("failed install perform step: %s", err)
   }
   return res, err
} installRelease函数比较简单，先进行预处理prepareRelease，然后没问题再执行performRelease，最后返回response

// prepareRelease builds a release for an install operation.
func (s *ReleaseServer) prepareRelease(req *services.InstallReleaseRequest) (*release.Release, error) {
   if req.Chart == nil {
      return nil, errMissingChart
   }

   name, err := s.uniqName(req.Name, req.ReuseName)
   if err != nil {
      return nil, err
   }

   caps, err := capabilities(s.clientset.Discovery())
   if err != nil {
      return nil, err
   }

   revision := 1
   ts := timeconv.Now()
   options := chartutil.ReleaseOptions{
      Name:      name,
      Time:      ts,
      Namespace: req.Namespace,
      Revision:  revision,
      IsInstall: true,
   }
   valuesToRender, err := chartutil.ToRenderValuesCaps(req.Chart, req.Values, options, caps)
   if err != nil {
      return nil, err
   }

   hooks, manifestDoc, notesTxt, err := s.renderResources(req.Chart, valuesToRender, caps.APIVersions)
   if err != nil {
      // Return a release with partial data so that client can show debugging
      // information.
      rel := &release.Release{
         Name:      name,
         Namespace: req.Namespace,
         Chart:     req.Chart,
         Config:    req.Values,
         Info: &release.Info{
            FirstDeployed: ts,
            LastDeployed:  ts,
            Status:        &release.Status{Code: release.Status_UNKNOWN},
            Description:   fmt.Sprintf("Install failed: %s", err),
         },
         Version: 0,
      }
      if manifestDoc != nil {
         rel.Manifest = manifestDoc.String()
      }
      return rel, err
   }

   // Store a release.
   rel := &release.Release{
      Name:      name,
      Namespace: req.Namespace,
      Chart:     req.Chart,
      Config:    req.Values,
      Info: &release.Info{
         FirstDeployed: ts,
         LastDeployed:  ts,
         Status:        &release.Status{Code: release.Status_UNKNOWN},
         Description:   "Initial install underway", // Will be overwritten.
      },
      Manifest: manifestDoc.String(),
      Hooks:    hooks,
      Version:  int32(revision),
   }
   if len(notesTxt) > 0 {
      rel.Info.Status.Notes = notesTxt
   }

   err = validateManifest(s.env.KubeClient, req.Namespace, manifestDoc.Bytes())
   return rel, err
} 检查是否重名，如果没重或者与之前已经被删除的Release重了的话，就正常返回，否则报错。<br /> 获取所有支持的API、kubernetes、tiller的版本号。<br /> 配置Release需要的额外状态参数。<br /> 获取填模板所用的字典。<br /> 根据request和上面获取的字典和API版本号，验证确认API版本号，渲染模板文件内容，隔离NOTES.txt，为各个文件建立manifest和hook对象并按照installorder排序（renderResource函数的作用）。<br /> 根据上面的内容新建一个release对象。<br /> 验证提供文件内容的合法性。

// performRelease runs a release.
func (s *ReleaseServer) performRelease(r *release.Release, req *services.InstallReleaseRequest) (*services.InstallReleaseResponse, error) {
   res := &services.InstallReleaseResponse{Release: r}

   if req.DryRun {
      s.Log("dry run for %s", r.Name)
      res.Release.Info.Description = "Dry run complete"
      return res, nil
   }

   // pre-install hooks
   if !req.DisableHooks {
      if err := s.execHook(r.Hooks, r.Name, r.Namespace, hooks.PreInstall, req.Timeout); err != nil {
         return res, err
      }
   } else {
      s.Log("install hooks disabled for %s", req.Name)
   }

   switch h, err := s.env.Releases.History(req.Name); {
   // if this is a replace operation, append to the release history
   case req.ReuseName && err == nil && len(h) >= 1:
      s.Log("name reuse for %s requested, replacing release", req.Name)
      // get latest release revision
      relutil.Reverse(h, relutil.SortByRevision)

      // old release
      old := h[0]

      // update old release status
      old.Info.Status.Code = release.Status_SUPERSEDED
      s.recordRelease(old, true)

      // update new release with next revision number
      // so as to append to the old release's history
      r.Version = old.Version + 1
      updateReq := &services.UpdateReleaseRequest{
         Wait:     req.Wait,
         Recreate: false,
         Timeout:  req.Timeout,
      }
      if err := s.ReleaseModule.Update(old, r, updateReq, s.env); err != nil {
         msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err)
         s.Log("warning: %s", msg)
         old.Info.Status.Code = release.Status_SUPERSEDED
         r.Info.Status.Code = release.Status_FAILED
         r.Info.Description = msg
         s.recordRelease(old, true)
         s.recordRelease(r, false)
         return res, err
      }

   default:
      // nothing to replace, create as normal
      // regular manifests
      if err := s.ReleaseModule.Create(r, req, s.env); err != nil {
         msg := fmt.Sprintf("Release %q failed: %s", r.Name, err)
         s.Log("warning: %s", msg)
         r.Info.Status.Code = release.Status_FAILED
         r.Info.Description = msg
         s.recordRelease(r, false)
         return res, fmt.Errorf("release %s failed: %s", r.Name, err)
      }
   }

   // post-install hooks
   if !req.DisableHooks {
      if err := s.execHook(r.Hooks, r.Name, r.Namespace, hooks.PostInstall, req.Timeout); err != nil {
         msg := fmt.Sprintf("Release %q failed post-install: %s", r.Name, err)
         s.Log("warning: %s", msg)
         r.Info.Status.Code = release.Status_FAILED
         r.Info.Description = msg
         s.recordRelease(r, false)
         return res, err
      }
   }

   r.Info.Status.Code = release.Status_DEPLOYED
   r.Info.Description = "Install complete"
   // This is a tricky case. The release has been created, but the result
   // cannot be recorded. The truest thing to tell the user is that the
   // release was created. However, the user will not be able to do anything
   // further with this release.
   //
   // One possible strategy would be to do a timed retry to see if we can get
   // this stored in the future.
   s.recordRelease(r, false)

   return res, nil
}