From 063e37525cb8e66a440cdf3b2b0b1e00aa80266a Mon Sep 17 00:00:00 2001 From: Matt Butcher Date: Fri, 15 Jan 2016 12:53:31 -0700 Subject: [PATCH] feat(*): add install/deploy command --- cmd/deploy.go | 24 ++++++++ cmd/helm.go | 68 +++++++++++++++++++-- cmd/properties.go | 40 +++++++++++++ deploy/deploy.go | 148 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 276 insertions(+), 4 deletions(-) create mode 100644 cmd/deploy.go create mode 100644 cmd/properties.go create mode 100644 deploy/deploy.go diff --git a/cmd/deploy.go b/cmd/deploy.go new file mode 100644 index 000000000..8126ca4e4 --- /dev/null +++ b/cmd/deploy.go @@ -0,0 +1,24 @@ +package main + +import ( + "errors" + + dep "github.com/deis/helm-dm/deploy" + "github.com/deis/helm-dm/format" +) + +func deploy(cfg *dep.Deployment, dry bool) error { + if dry { + format.Error("Not implemented: --dry-run") + } + if cfg.Filename == "" { + return errors.New("A filename must be specified. For a tar archive, this is the name of the root template in the archive.") + } + + if err := cfg.Commit(); err != nil { + format.Error("Failed to commit deployment: %s", err) + return err + } + + return nil +} diff --git a/cmd/helm.go b/cmd/helm.go index d69ebd667..d0edde4bb 100644 --- a/cmd/helm.go +++ b/cmd/helm.go @@ -4,6 +4,7 @@ import ( "os" "github.com/codegangsta/cli" + dep "github.com/deis/helm-dm/deploy" "github.com/deis/helm-dm/format" ) @@ -22,7 +23,7 @@ func main() { func commands() []cli.Command { return []cli.Command{ { - Name: "install", + Name: "init", Usage: "Initialize the client and install DM on Kubernetes.", Description: ``, Flags: []cli.Flag{ @@ -33,7 +34,7 @@ func commands() []cli.Command { }, Action: func(c *cli.Context) { if err := install(c.Bool("dry-run")); err != nil { - format.Error(err.Error()) + format.Error("%s (Run 'helm doctor' for more information)", err) os.Exit(1) } }, @@ -44,7 +45,7 @@ func commands() []cli.Command { ArgsUsage: "", Action: func(c *cli.Context) { if err := target(c.Bool("dry-run")); err != nil { - format.Error(err.Error()) + format.Error("%s (Is the cluster running?)", err) os.Exit(1) } }, @@ -59,7 +60,66 @@ func commands() []cli.Command { Name: "doctor", }, { - Name: "deploy", + Name: "deploy", + Aliases: []string{"install"}, + Usage: "Deploy a chart into the cluster.", + Action: func(c *cli.Context) { + + args := c.Args() + if len(args) < 1 { + format.Error("First argument, filename, is required. Try 'helm deploy --help'") + os.Exit(1) + } + + props, err := parseProperties(c.String("properties")) + if err != nil { + format.Error("Failed to parse properties: %s", err) + os.Exit(1) + } + + d := &dep.Deployment{ + Name: c.String("Name"), + Properties: props, + Filename: args[0], + Imports: args[1:], + Repository: c.String("repository"), + } + + if c.Bool("stdin") { + d.Input = os.Stdin + } + + if err := deploy(d, c.Bool("dry-run")); err != nil { + format.Error("%s (Try running 'helm doctor')", err) + os.Exit(1) + } + }, + Flags: []cli.Flag{ + cli.BoolFlag{ + Name: "dry-run", + Usage: "Only display the underlying kubectl commands.", + }, + cli.BoolFlag{ + Name: "stdin,i", + Usage: "Read a configuration from STDIN.", + }, + cli.StringFlag{ + Name: "name", + Usage: "Name of deployment, used for deploy and update commands (defaults to template name)", + }, + // TODO: I think there is a Generic flag type that we can implement parsing with. + cli.StringFlag{ + Name: "properties,p", + Usage: "A comma-separated list of key=value pairs: 'foo=bar,foo2=baz'.", + }, + cli.StringFlag{ + // FIXME: This is not right. It's sort of a half-baked forward + // port of dm.go. + Name: "repository", + Usage: "The default repository", + Value: "kubernetes/application-dm-templates", + }, + }, }, { Name: "search", diff --git a/cmd/properties.go b/cmd/properties.go new file mode 100644 index 000000000..9632c95f6 --- /dev/null +++ b/cmd/properties.go @@ -0,0 +1,40 @@ +package main + +import ( + "errors" + "strconv" + "strings" +) + +// TODO: The concept of property here is really simple. We could definitely get +// better about the values we allow. Also, we need some validation on the names. + +var errInvalidProperty = errors.New("property is not in name=value format") + +// parseProperties is a utility for parsing a comma-separated key=value string. +func parseProperties(kvstr string) (map[string]interface{}, error) { + properties := map[string]interface{}{} + + if len(kvstr) == 0 { + return properties, nil + } + + pairs := strings.Split(kvstr, ",") + for _, p := range pairs { + // Allow for "k=v, k=v" + p = strings.TrimSpace(p) + pair := strings.Split(p, "=") + if len(pair) == 1 { + return properties, errInvalidProperty + } + + // If the value looks int-like, convert it. + if i, err := strconv.Atoi(pair[1]); err == nil { + properties[pair[0]] = pair[1] + } else { + properties[pair[0]] = i + } + } + + return properties, nil +} diff --git a/deploy/deploy.go b/deploy/deploy.go new file mode 100644 index 000000000..038c7eafa --- /dev/null +++ b/deploy/deploy.go @@ -0,0 +1,148 @@ +package deploy + +import ( + "archive/tar" + "errors" + "fmt" + "os" + "strings" + + "github.com/ghodss/yaml" + "github.com/kubernetes/deployment-manager/common" + "github.com/kubernetes/deployment-manager/expandybird/expander" + "github.com/kubernetes/deployment-manager/registry" +) + +type Deployer interface { + Commit() error +} + +// Deployment describes a deployment of a package. +type Deployment struct { + // Name is the Deployment name. Autogenerated if empty. + Name string + // Filename is the filename for the base deployment. + Filename string + // Imports is a list of imported files. + Imports []string + // Properties to pass into the template. + Properties map[string]interface{} + // Input is a file containing templates. It may be os.Stdin. + Input *os.File + // Repository is the location of the templates. + Repository string +} + +// Commit prepares the Deployment and then commits it to the remote processor. +func (d *Deployment) Commit() error { + tpl, err := d.resolveTemplate() + if err != nil { + return err + } + + // If a deployment Name is specified, set that explicitly. + if d.Name != "" { + tpl.Name = d.Name + } + + return nil +} + +// resolveTemplate resolves what kind of template is being loaded, and then returns the template. +func (d *Deployment) resolveTemplate() (*common.Template, error) { + // If some input has been specified, read it. + if d.Input != nil { + // Assume this is a tar archive. + tpl, err := expander.NewTemplateFromArchive(d.Filename, d.Input, d.Imports) + if err == nil { + return tpl, err + } else if err != tar.ErrHeader { + return nil, err + } + + // If we get here, the file is not a tar archive. + if _, err := os.Stdin.Seek(0, 0); err != nil { + return nil, err + } + return expander.NewTemplateFromReader(d.Filename, d.Input, d.Imports) + } + + // Non-Stdin case + if len(d.Imports) > 0 { + if t, err := registryType(d.Filename); err != nil { + return expander.NewTemplateFromRootTemplate(d.Filename) + } else { + return buildTemplateFromType(t, d.Repository, d.Properties) + } + } + return expander.NewTemplateFromFileNames(d.Filename, d.Imports) +} + +// registryType is a placeholder until registry.ParseType() is merged. +func registryType(name string) (*registry.Type, error) { + tList := strings.Split(name, ":") + if len(tList) != 2 { + return nil, errors.New("No version") + } + + tt := registry.Type{Version: tList[1]} + + cList := strings.Split(tList[0], "/") + + if len(cList) == 1 { + tt.Name = tList[0] + } else { + tt.Collection = cList[0] + tt.Name = cList[1] + } + return &tt, nil +} + +// buildTemplateFromType is a straight lift-n-shift from dm.go. +func buildTemplateFromType(t *registry.Type, reg string, props map[string]interface{}) (*common.Template, error) { + // Name the deployment after the type name. + name := fmt.Sprintf("%s:%s", t.Name, t.Version) + git, err := getGitRegistry(reg) + if err != nil { + return nil, err + } + gurls, err := git.GetURLs(*t) + if err != nil { + return nil, err + } + + config := common.Configuration{Resources: []*common.Resource{&common.Resource{ + Name: name, + Type: gurls[0], + Properties: props, + }}} + + y, err := yaml.Marshal(config) + if err != nil { + return nil, fmt.Errorf("error: %s\ncannot create configuration for deployment: %v\n", err, config) + } + + return &common.Template{ + Name: name, + Content: string(y), + // No imports, as this is a single type from repository. + }, nil +} + +func getGitRegistry(reg string) (registry.Registry, error) { + s := strings.SplitN(reg, "/", 3) + if len(s) < 2 { + return nil, fmt.Errorf("invalid template registry: %s", reg) + } + + path := "" + if len(s) > 2 { + path = s[3] + } + + if s[0] == "helm" { + return registry.NewGithubPackageRegistry(s[0], s[1]), nil + } else { + return registry.NewGithubRegistry(s[0], s[1], path), nil + } +}