server.go

package deployer

import (
	"fmt"
	"log"
	"net/http"

	"github.com/mholt/binding"
)

func CreateServer(ctx *Context) {
	http.HandleFunc("/builds", makeHandler(ctx, buildHandler))
	//http.HandleFunc("/releases", makeHandler(ctx, releaseHandler))
	http.HandleFunc("/deploys", makeHandler(ctx, deployHandler))

	log.Printf(fmt.Sprintf("Listening on port %v", ctx.Config.Port))
	http.ListenAndServe(fmt.Sprintf(":%v", ctx.Config.Port), nil)
}

func makeHandler(ctx *Context, handler func(*Context, http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
	return func(rw http.ResponseWriter, req *http.Request) {
		err := handler(ctx, rw, req)
		if (err)
	}
}

func buildHandler(ctx *Context, rw http.ResponseWriter, req *http.Request) {
	// Create new build
	build = new(Build)
	errs := binding.Bind(req, build)
	if errs.Handle(rw) {
		return
	}

	err := build.Save(ctx.Db)
	if (err) {
		return err
	}

	// Notify any pending releases that their dependent build may now exist.
	ctx.NewBuilds <- &build
}

func releaseHandler(ctx *Context, rw http.ResponseWriter, req *http.Request) {
	build = new(Build)
	errs := binding.Bind(req, build)
	if errs.Handle(rw) {
		return
	}

	exists, err := build.Exists(ctx.Db)
	if (err) {
		return err
	}

	// If the build does not already exist, wait for it to be created.
	if !exists {
		ctx.NewBuilds ->
	}

	// At this point, since the build exists, it is now safe to create and
	// deploy a release.
	release := Release.Create(ctx.Db, build)
}

/*
func releaseHandler(ctx *Context, rw http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	if err != nil {
		return "Unable to parse form"
	}

	release := Release{}
	decoder := schema.NewDecoder()
	err := decoder.Decode(release, req.PostForm)

	if (err == nil) {
		return err
	}

	service := req.Form.Get("service")
	build := req.Form.Get("build")

		Release.Wait(ctx)
		Release.AddMetadata()
		Release.Save(ctx)

		return Release.Id

	// Wait until service has build
	//// initial check
	///  or listen to ctx.chan

	// Create release and save it to the database.
	release := Release{service: service, build: build}
	release.save(ctx.db)

	rw.Write(release.Id)

	err = ctx.Db.Update(func(tx *bolt.Tx) error {
		b, err := tx.CreateBucketIfNotExists([]byte("releases"))
		if err != nil {
			return err
		}
		err = b.Put([]byte(service), []byte(build))
		return err
	})

	if err != nil {
		return "Unable to update database: " // err
	}

	log.Println(req.Form)
	// Ensure both exist
	// Ensure service exists
	//req.service req.build
	// if req.service and req.build do not already exist, wait
	// Generate release from last one and assign naming and all
	// save release to database.
}
*/

func deployHandler(ctx *Context, rw http.ResponseWriter, req *http.Request) {
	// Ensure both exist
	//req.from req.to
	// ensure to (if integer) is valid release
	// else if string, ensure valid environment
	// ensure to is valid environment
	// set environment deploys...
}