func main() {
conf := &terraformer.Config{}
mc := multiconfig.New()
mc.Loader = multiconfig.MultiLoader(
&multiconfig.TagLoader{},
&multiconfig.EnvironmentLoader{},
&multiconfig.EnvironmentLoader{Prefix: "KONFIG_TERRAFORMER"},
&multiconfig.FlagLoader{},
)
mc.MustLoad(conf)
if !conf.TerraformDebug {
// hashicorp.terraform outputs many logs, discard them
log.SetOutput(ioutil.Discard)
}
log := logging.NewCustom(terraformer.Name, conf.Debug)
// init terraformer
t, err := terraformer.New(conf, log)
if err != nil {
log.Fatal(err.Error())
}
k, err := terraformer.NewKite(t, conf)
if err != nil {
log.Fatal(err.Error())
}
if err := k.RegisterForever(k.RegisterURL(true)); err != nil {
log.Fatal(err.Error())
}
go k.Run()
<-k.ServerReadyNotify()
log.Debug("Kite Started Listening")
// terraformer can only be closed with signals, wait for any signal
if err := t.Wait(); err != nil {
log.Error("Err after waiting terraformer %s", err)
}
k.Close()
}
func init() {
if s := os.Getenv("KLOUD_TEST_REGION"); s != "" {
team.Region = s
}
if s := os.Getenv("KLOUD_TEST_INSTANCE_TYPE"); s != "" {
team.InstanceType = s
}
repoPath, err := currentRepoPath()
if err != nil {
log.Fatal("currentRepoPath error:", err)
}
conf = config.New()
conf.Username = "******"
conf.KontrolURL = os.Getenv("KLOUD_KONTROL_URL")
if conf.KontrolURL == "" {
conf.KontrolURL = "http://localhost:4099/kite"
}
conf.KontrolKey = testkeys.Public
conf.KontrolUser = "******"
conf.KiteKey = testutil.NewKiteKey().Raw
// Power up our own kontrol kite for self-contained tests
log.Println("Starting Kontrol Test Instance")
kontrol.DefaultPort = 4099
kntrl := kontrol.New(conf.Copy(), "0.1.0")
p := kontrol.NewPostgres(nil, kntrl.Kite.Log)
kntrl.SetKeyPairStorage(p)
kntrl.SetStorage(p)
kntrl.AddKeyPair("", testkeys.Public, testkeys.Private)
go kntrl.Run()
<-kntrl.Kite.ServerReadyNotify()
// Power up kloud kite
log.Println("Starting Kloud Test Instance")
kloudKite = kite.New("kloud", "0.0.1")
kloudKite.Config = conf.Copy()
kloudKite.Config.Port = 4002
kiteURL := &url.URL{Scheme: "http", Host: "localhost:4002", Path: "/kite"}
_, err = kloudKite.Register(kiteURL)
if err != nil {
log.Fatal("kloud ", err.Error())
}
awsProvider, slProvider = providers()
// Add Kloud handlers
kld := kloudWithProviders(awsProvider, slProvider)
kloudKite.HandleFunc("plan", kld.Plan)
kloudKite.HandleFunc("apply", kld.Apply)
kloudKite.HandleFunc("bootstrap", kld.Bootstrap)
kloudKite.HandleFunc("authenticate", kld.Authenticate)
kloudKite.HandleFunc("build", kld.Build)
kloudKite.HandleFunc("destroy", kld.Destroy)
kloudKite.HandleFunc("stop", kld.Stop)
kloudKite.HandleFunc("start", kld.Start)
kloudKite.HandleFunc("reinit", kld.Reinit)
kloudKite.HandleFunc("resize", kld.Resize)
kloudKite.HandleFunc("restart", kld.Restart)
kloudKite.HandleFunc("event", kld.Event)
kloudKite.HandleFunc("createSnapshot", kld.CreateSnapshot)
kloudKite.HandleFunc("deleteSnapshot", kld.DeleteSnapshot)
go kloudKite.Run()
<-kloudKite.ServerReadyNotify()
// Power up our terraformer kite
log.Println("Starting Terraform Test Instance")
tConf := &terraformer.Config{
Port: 2300,
Region: "dev",
Environment: "dev",
AWS: terraformer.AWS{
Key: os.Getenv("TERRAFORMER_KEY"),
Secret: os.Getenv("TERRAFORMER_SECRET"),
Bucket: "koding-terraformer-state-dev",
},
LocalStorePath: filepath.Join(repoPath, filepath.FromSlash("go/data/terraformer")),
}
t, err := terraformer.New(tConf, logging.NewCustom("terraformer", false))
if err != nil {
log.Fatal("terraformer ", err.Error())
}
terraformerKite, err := terraformer.NewKite(t, tConf)
if err != nil {
log.Fatal("terraformer ", err.Error())
}
// no need to register to kontrol, kloud talks directly via a secret key
terraformerKite.Config = conf.Copy()
terraformerKite.Config.Port = 2300
go terraformerKite.Run()
<-terraformerKite.ServerReadyNotify()
log.Println("=== Test instances are up and ready!. Executing now the tests... ===")
// hashicorp.terraform outputs many logs, discard them
log.SetOutput(ioutil.Discard)
}