terraform/commands.go

186 lines
3.6 KiB
Go
Raw Normal View History

2014-05-24 21:04:43 +02:00
package main
import (
"os"
2014-07-03 02:01:02 +02:00
"os/signal"
2014-05-24 21:04:43 +02:00
"github.com/hashicorp/terraform/command"
"github.com/mitchellh/cli"
)
// Commands is the mapping of all the available Terraform commands.
var Commands map[string]cli.CommandFactory
var PlumbingCommands map[string]struct{}
2014-05-24 21:04:43 +02:00
2014-06-27 02:05:21 +02:00
// Ui is the cli.Ui used for communicating to the outside world.
var Ui cli.Ui
const (
ErrorPrefix = "e:"
OutputPrefix = "o:"
)
2014-05-24 21:04:43 +02:00
func init() {
2014-06-27 02:05:21 +02:00
Ui = &cli.PrefixedUi{
AskPrefix: OutputPrefix,
OutputPrefix: OutputPrefix,
InfoPrefix: OutputPrefix,
ErrorPrefix: ErrorPrefix,
Ui: &cli.BasicUi{Writer: os.Stdout},
}
2014-05-24 21:04:43 +02:00
meta := command.Meta{
2014-07-28 17:56:34 +02:00
Color: true,
ContextOpts: &ContextOpts,
Ui: Ui,
}
PlumbingCommands = map[string]struct{}{
"state": struct{}{}, // includes all subcommands
}
2014-05-24 21:04:43 +02:00
Commands = map[string]cli.CommandFactory{
2014-05-24 21:27:58 +02:00
"apply": func() (cli.Command, error) {
return &command.ApplyCommand{
Meta: meta,
ShutdownCh: makeShutdownCh(),
2014-05-24 21:27:58 +02:00
}, nil
},
2014-10-01 06:51:45 +02:00
"destroy": func() (cli.Command, error) {
return &command.ApplyCommand{
Meta: meta,
Destroy: true,
ShutdownCh: makeShutdownCh(),
}, nil
},
"fmt": func() (cli.Command, error) {
return &command.FmtCommand{
Meta: meta,
}, nil
},
"get": func() (cli.Command, error) {
return &command.GetCommand{
Meta: meta,
}, nil
},
2014-07-01 19:02:13 +02:00
"graph": func() (cli.Command, error) {
return &command.GraphCommand{
Meta: meta,
2014-07-01 19:02:13 +02:00
}, nil
},
2014-09-27 21:31:38 +02:00
"init": func() (cli.Command, error) {
return &command.InitCommand{
Meta: meta,
}, nil
},
2014-07-13 19:25:42 +02:00
"output": func() (cli.Command, error) {
return &command.OutputCommand{
Meta: meta,
}, nil
},
2014-06-20 20:47:02 +02:00
"plan": func() (cli.Command, error) {
return &command.PlanCommand{
Meta: meta,
}, nil
},
2015-03-05 05:42:26 +01:00
"push": func() (cli.Command, error) {
return &command.PushCommand{
Meta: meta,
}, nil
},
2014-06-27 20:09:01 +02:00
"refresh": func() (cli.Command, error) {
return &command.RefreshCommand{
Meta: meta,
2014-06-27 20:09:01 +02:00
}, nil
},
2014-10-10 00:05:53 +02:00
"remote": func() (cli.Command, error) {
return &command.RemoteCommand{
Meta: meta,
}, nil
},
2014-07-13 04:47:31 +02:00
"show": func() (cli.Command, error) {
return &command.ShowCommand{
Meta: meta,
2014-07-13 04:47:31 +02:00
}, nil
},
2015-02-26 19:29:51 +01:00
"taint": func() (cli.Command, error) {
return &command.TaintCommand{
Meta: meta,
}, nil
},
2015-11-05 15:47:08 +01:00
"validate": func() (cli.Command, error) {
return &command.ValidateCommand{
Meta: meta,
}, nil
},
2014-05-24 21:04:43 +02:00
"version": func() (cli.Command, error) {
return &command.VersionCommand{
2014-07-13 19:42:18 +02:00
Meta: meta,
2014-05-24 21:04:43 +02:00
Revision: GitCommit,
Version: Version,
VersionPrerelease: VersionPrerelease,
2014-10-13 23:05:29 +02:00
CheckFunc: commandVersionCheck,
2014-05-24 21:04:43 +02:00
}, nil
},
"untaint": func() (cli.Command, error) {
return &command.UntaintCommand{
Meta: meta,
}, nil
},
//-----------------------------------------------------------
// Plumbing
//-----------------------------------------------------------
"state": func() (cli.Command, error) {
return &command.StateCommand{
Meta: meta,
}, nil
},
"state list": func() (cli.Command, error) {
return &command.StateListCommand{
Meta: meta,
}, nil
},
2016-03-25 18:17:25 +01:00
"state show": func() (cli.Command, error) {
return &command.StateShowCommand{
Meta: meta,
}, nil
},
2014-05-24 21:04:43 +02:00
}
}
2014-07-03 02:01:02 +02:00
// makeShutdownCh creates an interrupt listener and returns a channel.
// A message will be sent on the channel for every interrupt received.
func makeShutdownCh() <-chan struct{} {
resultCh := make(chan struct{})
signalCh := make(chan os.Signal, 4)
signal.Notify(signalCh, os.Interrupt)
go func() {
for {
<-signalCh
resultCh <- struct{}{}
}
}()
return resultCh
}