harness-drone/server/queue.go

package server

import (
	"encoding/json"
	"io"
	"net"
	"strconv"

	log "github.com/Sirupsen/logrus"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"

	"github.com/drone/drone/common"
	"github.com/drone/drone/eventbus"
)

// TODO (bradrydzewski) the callback URL should be signed.
// TODO (bradrydzewski) we shouldn't need to fetch the Repo if specified in the URL path
// TODO (bradrydzewski) use SetRepoLast to update the last repository

// GET /queue/pull
func PollBuild(c *gin.Context) {
	queue := ToQueue(c)
	store := ToDatastore(c)
	agent := &common.Agent{
		Addr: c.Request.RemoteAddr,
	}

	// extact the host port and name and
	// replace with the default agent port (1999)
	host, _, err := net.SplitHostPort(agent.Addr)
	if err == nil {
		agent.Addr = host
	}
	agent.Addr = net.JoinHostPort(agent.Addr, "1999")

	log.Infof("agent connected and polling builds at %s", agent.Addr)

	work := queue.PullClose(c.Writer)
	if work == nil {
		c.AbortWithStatus(500)
		return
	}

	// TODO (bradrydzewski) decide how we want to handle a failure here
	// still not sure exact behavior we want ...
	err = store.SetBuildAgent(work.Repo.FullName, work.Build.Number, agent)
	if err != nil {
		log.Errorf("error persisting build agent. %s", err)
	}

	c.JSON(200, work)

	// acknowledge work received by the client
	queue.Ack(work)
}

// GET /queue/push/:owner/:repo
func PushBuild(c *gin.Context) {
	store := ToDatastore(c)
	repo := ToRepo(c)
	bus := ToBus(c)
	in := &common.Build{}
	if !c.BindWith(in, binding.JSON) {
		return
	}
	build, err := store.Build(repo.FullName, in.Number)
	if err != nil {
		c.Fail(404, err)
		return
	}

	if in.State != common.StatePending && in.State != common.StateRunning {
		store.DelBuildAgent(repo.FullName, build.Number)
	}

	build.Duration = in.Duration
	build.Started = in.Started
	build.Finished = in.Finished
	build.State = in.State
	err = store.SetBuildState(repo.FullName, build)
	if err != nil {
		c.Fail(500, err)
		return
	}

	if build.State != common.StatePending && build.State != common.StateRunning {
		if repo.Last == nil || build.Number >= repo.Last.Number {
			repo.Last = build
			store.SetRepo(repo)
		}
	}

	// <-- FIXME
	// for some reason the Repo and Build fail to marshal to JSON.
	// It has something to do with memory / pointers. So it goes away
	// if I just refetch these items. Needs to be fixed in the future,
	// but for now should be ok
	repo, err = store.Repo(repo.FullName)
	if err != nil {
		c.Fail(500, err)
		return
	}
	build, err = store.Build(repo.FullName, in.Number)
	if err != nil {
		c.Fail(404, err)
		return
	}
	// END FIXME -->

	msg, err := json.Marshal(build)
	if err == nil {
		c.String(200, err.Error()) // we can ignore this error
		return
	}

	bus.Send(&eventbus.Event{
		Name: repo.FullName,
		Kind: eventbus.EventRepo,
		Msg:  msg,
	})

	c.Writer.WriteHeader(200)
}

// POST /queue/push/:owner/:repo/:build
func PushTask(c *gin.Context) {
	store := ToDatastore(c)
	repo := ToRepo(c)
	bus := ToBus(c)
	num, _ := strconv.Atoi(c.Params.ByName("build"))
	in := &common.Task{}
	if !c.BindWith(in, binding.JSON) {
		return
	}
	err := store.SetBuildTask(repo.FullName, num, in)
	if err != nil {
		c.Fail(404, err)
		return
	}
	build, err := store.Build(repo.FullName, num)
	if err != nil {
		c.Fail(404, err)
		return
	}

	msg, err := json.Marshal(build)
	if err == nil {
		c.String(200, err.Error()) // we can ignore this error
		return
	}

	bus.Send(&eventbus.Event{
		Name: repo.FullName,
		Kind: eventbus.EventRepo,
		Msg:  msg,
	})

	c.Writer.WriteHeader(200)
}

// POST /queue/push/:owner/:repo/:build/:task/logs
func PushLogs(c *gin.Context) {
	store := ToDatastore(c)
	repo := ToRepo(c)
	bnum, _ := strconv.Atoi(c.Params.ByName("build"))
	tnum, _ := strconv.Atoi(c.Params.ByName("task"))

	const maxBuffToRead int64 = 5000000 // 5MB.
	err := store.SetLogs(repo.FullName, bnum, tnum, io.LimitReader(c.Request.Body, maxBuffToRead))
	if err != nil {
		c.Fail(500, err)
		return
	}
	c.Writer.WriteHeader(200)
}

func GetQueue(c *gin.Context) {
	queue := ToQueue(c)
	items := queue.Items()
	c.JSON(200, items)
}