1
0
mirror of https://github.com/woodpecker-ci/woodpecker.git synced 2024-11-30 08:06:52 +02:00
woodpecker/cmd/drone-server/drone.go

284 lines
7.1 KiB
Go
Raw Normal View History

package main
import (
"html/template"
"net/http"
2015-08-06 18:22:31 +02:00
"github.com/drone/drone/Godeps/_workspace/src/github.com/namsral/flag"
2015-08-06 17:54:47 +02:00
2015-05-22 20:37:40 +02:00
"github.com/drone/drone/Godeps/_workspace/src/github.com/gin-gonic/gin"
2015-04-09 01:19:25 +02:00
2015-05-22 20:37:40 +02:00
"github.com/drone/drone/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs"
2015-05-28 09:18:46 +02:00
"github.com/drone/drone/pkg/config"
2015-07-23 19:36:23 +02:00
"github.com/drone/drone/pkg/remote"
"github.com/drone/drone/pkg/server"
"github.com/drone/drone/pkg/server/session"
2015-04-24 23:25:03 +02:00
2015-05-22 20:37:40 +02:00
log "github.com/drone/drone/Godeps/_workspace/src/github.com/Sirupsen/logrus"
eventbus "github.com/drone/drone/pkg/bus/builtin"
2015-05-17 20:42:56 +02:00
queue "github.com/drone/drone/pkg/queue/builtin"
runner "github.com/drone/drone/pkg/runner/builtin"
2015-06-15 08:26:49 +02:00
"github.com/drone/drone/pkg/store"
_ "github.com/drone/drone/pkg/remote/builtin/github"
2015-07-26 14:32:49 +02:00
_ "github.com/drone/drone/pkg/remote/builtin/gitlab"
2015-06-15 08:26:49 +02:00
_ "github.com/drone/drone/pkg/store/builtin"
_ "net/http/pprof"
)
2015-05-18 19:05:58 +02:00
var (
// commit sha for the current build, set by
// the compile process.
version string
revision string
)
2015-08-06 17:54:47 +02:00
var conf = struct {
debug bool
server struct {
addr string
cert string
key string
}
session struct {
expiry string
secret string
}
docker struct {
host string
cert string
key string
ca string
}
remote struct {
driver string
config string
}
database struct {
driver string
config string
}
plugin struct {
filter string
}
}{}
func main() {
2015-08-06 17:54:47 +02:00
flag.StringVar(&conf.docker.host, "docker-host", "unix:///var/run/docker/docker.sock", "")
flag.StringVar(&conf.docker.cert, "docker-cert", "", "")
flag.StringVar(&conf.docker.key, "docker-key", "", "")
flag.StringVar(&conf.docker.ca, "docker-ca", "", "")
flag.StringVar(&conf.server.addr, "server-addr", ":8080", "")
flag.StringVar(&conf.server.cert, "server-cert", "", "")
flag.StringVar(&conf.server.key, "server-key", "", "")
flag.StringVar(&conf.session.expiry, "session-expiry", "", "")
flag.StringVar(&conf.session.secret, "session-secret", "", "")
flag.StringVar(&conf.remote.driver, "remote-driver", "github", "")
flag.StringVar(&conf.remote.config, "remote-config", "https://github.com", "")
flag.StringVar(&conf.database.driver, "database-driver", "sqlite3", "")
flag.StringVar(&conf.database.config, "database-config", "drone.sqlite", "")
flag.StringVar(&conf.plugin.filter, "plugin-filter", "plugins/*", "")
flag.BoolVar(&conf.debug, "debug", false, "")
flag.String("config", "", "")
2015-04-09 01:59:57 +02:00
flag.Parse()
2015-04-09 01:19:25 +02:00
2015-08-04 20:20:37 +02:00
settings, err := config.Load()
2015-04-09 01:19:25 +02:00
if err != nil {
panic(err)
}
2015-08-06 17:54:47 +02:00
store, err := store.New(conf.database.driver, conf.database.config)
2015-06-15 08:26:49 +02:00
if err != nil {
panic(err)
}
2015-08-06 17:54:47 +02:00
remote, err := remote.New(conf.remote.driver, conf.remote.config)
2015-07-23 19:36:23 +02:00
if err != nil {
panic(err)
}
2015-08-04 20:20:37 +02:00
2015-05-28 09:18:46 +02:00
session := session.New(settings)
eventbus_ := eventbus.New()
queue_ := queue.New()
2015-05-10 05:46:32 +02:00
updater := runner.NewUpdater(eventbus_, store, remote)
2015-05-05 10:07:35 +02:00
runner_ := runner.Runner{Updater: updater}
// launch the local queue runner if the system
// is not conifugred to run in agent mode
2015-05-28 09:18:46 +02:00
if len(settings.Agents.Secret) != 0 {
log.Infof("Run builds using remote build agents")
} else {
log.Infof("Run builds using the embedded build runner")
go run(&runner_, queue_)
}
2015-04-09 01:19:25 +02:00
r := gin.Default()
api := r.Group("/api")
api.Use(server.SetHeaders())
api.Use(server.SetBus(eventbus_))
api.Use(server.SetDatastore(store))
2015-04-09 01:19:25 +02:00
api.Use(server.SetRemote(remote))
api.Use(server.SetQueue(queue_))
2015-04-09 01:19:25 +02:00
api.Use(server.SetSettings(settings))
2015-04-30 23:23:46 +02:00
api.Use(server.SetSession(session))
2015-04-09 01:19:25 +02:00
api.Use(server.SetUser(session))
2015-05-06 10:24:55 +02:00
api.Use(server.SetRunner(&runner_))
2015-06-23 20:35:21 +02:00
api.OPTIONS("/*path", func(c *gin.Context) {})
2015-04-09 01:19:25 +02:00
user := api.Group("/user")
{
user.Use(server.MustUser())
user.GET("", server.GetUserCurr)
user.PATCH("", server.PutUserCurr)
2015-04-09 01:19:25 +02:00
user.GET("/repos", server.GetUserRepos)
2015-04-13 10:22:51 +02:00
user.GET("/tokens", server.GetUserTokens)
user.POST("/tokens", server.PostToken)
user.DELETE("/tokens/:label", server.DelToken)
2015-04-09 01:19:25 +02:00
}
users := api.Group("/users")
{
users.Use(server.MustAdmin())
users.GET("", server.GetUsers)
users.GET("/:name", server.GetUser)
users.POST("/:name", server.PostUser)
users.PATCH("/:name", server.PutUser)
2015-04-09 01:19:25 +02:00
users.DELETE("/:name", server.DeleteUser)
}
repos := api.Group("/repos/:owner/:name")
{
repos.POST("", server.PostRepo)
repo := repos.Group("")
{
repo.Use(server.SetRepo())
repo.Use(server.SetPerm())
repo.Use(server.CheckPull())
repo.Use(server.CheckPush())
repo.GET("", server.GetRepo)
repo.PATCH("", server.PutRepo)
2015-04-09 01:19:25 +02:00
repo.DELETE("", server.DeleteRepo)
repo.POST("/watch", server.Subscribe)
repo.DELETE("/unwatch", server.Unsubscribe)
repo.GET("/builds", server.GetCommits)
repo.GET("/builds/:number", server.GetCommit)
2015-04-17 07:07:13 +02:00
repo.POST("/builds/:number", server.RunBuild)
repo.DELETE("/builds/:number", server.KillBuild)
repo.GET("/logs/:number/:task", server.GetLogs)
// repo.POST("/status/:number", server.PostBuildStatus)
2015-04-09 01:19:25 +02:00
}
}
badges := api.Group("/badges/:owner/:name")
{
badges.Use(server.SetRepo())
badges.GET("/status.svg", server.GetBadge)
badges.GET("/cc.xml", server.GetCC)
}
hooks := api.Group("/hook")
{
hooks.POST("", server.PostHook)
}
queue := api.Group("/queue")
{
queue.Use(server.MustAgent())
queue.Use(server.SetSettings(settings))
queue.Use(server.SetUpdater(updater))
queue.POST("/pull", server.PollBuild)
push := queue.Group("/push/:owner/:name")
{
push.Use(server.SetRepo())
push.POST("", server.PushCommit)
push.POST("/:commit", server.PushBuild)
push.POST("/:commit/:build/logs", server.PushLogs)
}
}
2015-04-24 23:25:03 +02:00
2015-05-06 05:26:57 +02:00
stream := api.Group("/stream")
2015-04-25 02:06:46 +02:00
{
2015-05-06 05:26:57 +02:00
stream.Use(server.SetRepo())
stream.Use(server.SetPerm())
stream.GET("/:owner/:name", server.GetRepoEvents)
stream.GET("/:owner/:name/:build/:number", server.GetStream)
2015-04-30 04:57:43 +02:00
2015-04-25 02:06:46 +02:00
}
2015-04-09 01:19:25 +02:00
auth := r.Group("/authorize")
{
auth.Use(server.SetHeaders())
auth.Use(server.SetDatastore(store))
2015-04-09 01:19:25 +02:00
auth.Use(server.SetRemote(remote))
auth.Use(server.SetSettings(settings))
auth.Use(server.SetSession(session))
auth.GET("", server.GetLogin)
auth.POST("", server.GetLogin)
}
r.SetHTMLTemplate(index())
2015-04-09 01:19:25 +02:00
r.NoRoute(func(c *gin.Context) {
c.HTML(200, "index.html", nil)
2015-04-09 01:19:25 +02:00
})
http.Handle("/static/", static())
http.Handle("/", r)
2015-05-19 23:26:35 +02:00
err = http.ListenAndServe(settings.Server.Addr, nil)
if err != nil {
log.Error("Cannot start server: ", err)
}
}
// static is a helper function that will setup handlers
// for serving static files.
func static() http.Handler {
// default file server is embedded
var handler = http.FileServer(&assetfs.AssetFS{
Asset: Asset,
AssetDir: AssetDir,
Prefix: "cmd/drone-server/static",
})
2015-08-06 17:54:47 +02:00
if conf.debug {
handler = http.FileServer(
http.Dir("cmd/drone-server/static"),
)
}
return http.StripPrefix("/static/", handler)
}
// index is a helper function that will setup a template
// for rendering the main angular index.html file.
func index() *template.Template {
file := MustAsset("cmd/drone-server/static/index.html")
filestr := string(file)
return template.Must(template.New("index.html").Parse(filestr))
}
// run is a helper function for initializing the
// built-in build runner, if not running in remote
// mode.
func run(r *runner.Runner, q *queue.Queue) {
defer func() {
recover()
}()
r.Poll(q)
}