bump to 0.5 in master

router/middleware/agent.go

@@ -1,45 +1,33 @@
 package middleware
 
 import (
+	"github.com/codegangsta/cli"
 	"github.com/drone/drone/shared/token"
 
 	"github.com/Sirupsen/logrus"
 	"github.com/gin-gonic/gin"
-	"github.com/ianschenck/envflag"
 )
 
-var (
-	secret = envflag.String("DRONE_AGENT_SECRET", "", "")
-	noauth = envflag.Bool("AGENT_NO_AUTH", false, "")
-)
+const agentKey = "agent"
 
-// Agent is a middleware function that initializes the authorization middleware
+// Agents is a middleware function that initializes the authorization middleware
 // for agents to connect to the queue.
-func AgentMust() gin.HandlerFunc {
-
-	if *secret == "" {
-		logrus.Fatalf("please provide the agent secret to authenticate agent requests")
+func Agents(cli *cli.Context) gin.HandlerFunc {
+	secret := cli.String("agent-secret")
+	if secret == "" {
+		logrus.Fatalf("failed to generate token from DRONE_AGENT_SECRET")
 	}
 
-	t := token.New(token.AgentToken, "")
-	s, err := t.Sign(*secret)
+	t := token.New(secret, "")
+	s, err := t.Sign(secret)
 	if err != nil {
-		logrus.Fatalf("invalid agent secret. %s", err)
+		logrus.Fatalf("failed to generate token from DRONE_AGENT_SECRET. %s", err)
 	}
 
-	logrus.Infof("using agent secret %s", *secret)
+	logrus.Infof("using agent secret %s", secret)
 	logrus.Warnf("agents can connect with token %s", s)
 
 	return func(c *gin.Context) {
-		parsed, err := token.ParseRequest(c.Request, func(t *token.Token) (string, error) {
-			return *secret, nil
-		})
-		if err != nil {
-			c.AbortWithError(403, err)
-		} else if parsed.Kind != token.AgentToken {
-			c.AbortWithStatus(403)
-		} else {
-			c.Next()
-		}
+		c.Set(agentKey, secret)
 	}
 }

router/middleware/bus.go

@@ -0,0 +1,17 @@
+package middleware
+
+import (
+	"github.com/drone/drone/bus"
+
+	"github.com/codegangsta/cli"
+	"github.com/gin-gonic/gin"
+)
+
+// Bus is a middleware function that initializes the Event Bus and attaches to
+// the context of every http.Request.
+func Bus(cli *cli.Context) gin.HandlerFunc {
+	v := bus.New()
+	return func(c *gin.Context) {
+		bus.ToContext(c, v)
+	}
+}

router/middleware/cache.go

@@ -0,0 +1,24 @@
+package middleware
+
+import (
+	"github.com/drone/drone/cache"
+
+	"github.com/codegangsta/cli"
+	"github.com/gin-gonic/gin"
+)
+
+// Cache is a middleware function that initializes the Cache and attaches to
+// the context of every http.Request.
+func Cache(cli *cli.Context) gin.HandlerFunc {
+	v := setupCache(cli)
+	return func(c *gin.Context) {
+		cache.ToContext(c, v)
+	}
+}
+
+// helper function to create the cache from the CLI context.
+func setupCache(c *cli.Context) cache.Cache {
+	return cache.NewTTL(
+		c.Duration("cache-ttl"),
+	)
+}

router/middleware/config.go

@@ -0,0 +1,40 @@
+package middleware
+
+import (
+	"github.com/drone/drone/model"
+
+	"github.com/codegangsta/cli"
+	"github.com/gin-gonic/gin"
+)
+
+const configKey = "config"
+
+// Config is a middleware function that initializes the Configuration and
+// attaches to the context of every http.Request.
+func Config(cli *cli.Context) gin.HandlerFunc {
+	v := setupConfig(cli)
+	return func(c *gin.Context) {
+		c.Set(configKey, v)
+	}
+}
+
+// helper function to create the configuration from the CLI context.
+func setupConfig(c *cli.Context) *model.Config {
+	return &model.Config{
+		Open:   c.Bool("open"),
+		Yaml:   c.String("yaml"),
+		Shasum: c.String("yaml") + ".sig",
+		Secret: c.String("agent-secret"),
+		Admins: sliceToMap(c.StringSlice("admin")),
+		Orgs:   sliceToMap(c.StringSlice("orgs")),
+	}
+}
+
+// helper function to convert a string slice to a map.
+func sliceToMap(s []string) map[string]bool {
+	v := map[string]bool{}
+	for _, ss := range s {
+		v[ss] = true
+	}
+	return v
+}

router/middleware/queue.go

@@ -0,0 +1,17 @@
+package middleware
+
+import (
+	"github.com/drone/drone/queue"
+
+	"github.com/codegangsta/cli"
+	"github.com/gin-gonic/gin"
+)
+
+// Queue is a middleware function that initializes the Queue and attaches to
+// the context of every http.Request.
+func Queue(cli *cli.Context) gin.HandlerFunc {
+	v := queue.New()
+	return func(c *gin.Context) {
+		queue.ToContext(c, v)
+	}
+}

router/middleware/remote.go

@@ -0,0 +1,102 @@
+package middleware
+
+import (
+	"fmt"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/codegangsta/cli"
+	"github.com/drone/drone/remote"
+	"github.com/drone/drone/remote/bitbucket"
+	"github.com/drone/drone/remote/bitbucketserver"
+	"github.com/drone/drone/remote/github"
+	"github.com/drone/drone/remote/gitlab"
+	"github.com/drone/drone/remote/gogs"
+	"github.com/gin-gonic/gin"
+)
+
+// Remote is a middleware function that initializes the Remote and attaches to
+// the context of every http.Request.
+func Remote(c *cli.Context) gin.HandlerFunc {
+	v, err := setupRemote(c)
+	if err != nil {
+		logrus.Fatalln(err)
+	}
+	return func(c *gin.Context) {
+		remote.ToContext(c, v)
+	}
+}
+
+// helper function to setup the remote from the CLI arguments.
+func setupRemote(c *cli.Context) (remote.Remote, error) {
+	switch {
+	case c.Bool("github"):
+		return setupGithub(c)
+	case c.Bool("gitlab"):
+		return setupGitlab(c)
+	case c.Bool("bitbucket"):
+		return setupBitbucket(c)
+	case c.Bool("stash"):
+		return setupStash(c)
+	case c.Bool("gogs"):
+		return setupGogs(c)
+	default:
+		return nil, fmt.Errorf("version control system not configured")
+	}
+}
+
+// helper function to setup the Bitbucket remote from the CLI arguments.
+func setupBitbucket(c *cli.Context) (remote.Remote, error) {
+	return bitbucket.New(
+		c.String("bitbucket-client"),
+		c.String("bitbucket-server"),
+	), nil
+}
+
+// helper function to setup the Gogs remote from the CLI arguments.
+func setupGogs(c *cli.Context) (remote.Remote, error) {
+	return gogs.New(gogs.Opts{
+		URL:         c.String("gogs-server"),
+		Username:    c.String("gogs-git-username"),
+		Password:    c.String("gogs-git-password"),
+		PrivateMode: c.Bool("gogs-private-mode"),
+		SkipVerify:  c.Bool("gogs-skip-verify"),
+	})
+}
+
+// helper function to setup the Stash remote from the CLI arguments.
+func setupStash(c *cli.Context) (remote.Remote, error) {
+	return bitbucketserver.New(bitbucketserver.Opts{
+		URL:         c.String("stash-server"),
+		Username:    c.String("stash-git-username"),
+		Password:    c.String("stash-git-password"),
+		ConsumerKey: c.String("stash-consumer-key"),
+		ConsumerRSA: c.String("stash-consumer-rsa"),
+		SkipVerify:  c.Bool("stash-skip-verify"),
+	})
+}
+
+// helper function to setup the Gitlab remote from the CLI arguments.
+func setupGitlab(c *cli.Context) (remote.Remote, error) {
+	return gitlab.New(gitlab.Opts{
+		URL:         c.String("gitlab-server"),
+		Client:      c.String("gitlab-client"),
+		Secret:      c.String("gitlab-sercret"),
+		Username:    c.String("gitlab-git-username"),
+		Password:    c.String("gitlab-git-password"),
+		PrivateMode: c.Bool("gitlab-private-mode"),
+		SkipVerify:  c.Bool("gitlab-skip-verify"),
+	})
+}
+
+// helper function to setup the GitHub remote from the CLI arguments.
+func setupGithub(c *cli.Context) (remote.Remote, error) {
+	return github.New(
+		c.String("github-server"),
+		c.String("github-client"),
+		c.String("github-sercret"),
+		c.StringSlice("github-scope"),
+		c.Bool("github-private-mode"),
+		c.Bool("github-skip-verify"),
+		c.BoolT("github-merge-ref"),
+	)
+}

router/middleware/session/agent.go

@@ -0,0 +1,22 @@
+package session
+
+import (
+	"github.com/drone/drone/shared/token"
+	"github.com/gin-gonic/gin"
+)
+
+// AuthorizeAgent authorizes requsts from build agents to access the queue.
+func AuthorizeAgent(c *gin.Context) {
+	secret := c.MustGet("agent").(string)
+
+	parsed, err := token.ParseRequest(c.Request, func(t *token.Token) (string, error) {
+		return secret, nil
+	})
+	if err != nil {
+		c.AbortWithError(403, err)
+	} else if parsed.Kind != token.AgentToken {
+		c.AbortWithStatus(403)
+	} else {
+		c.Next()
+	}
+}

router/middleware/session/user.go

@@ -44,6 +44,10 @@ func SetUser() gin.HandlerFunc {
 			return user.Hash, err
 		})
 		if err == nil {
+			confv := c.MustGet("config")
+			if conf, ok := confv.(*model.Config); ok {
+				user.Admin = conf.IsAdmin(user)
+			}
 			c.Set("user", user)
 
 			// if this is a session token (ie not the API token)

router/middleware/store.go

@@ -0,0 +1,27 @@
+package middleware
+
+import (
+	"github.com/codegangsta/cli"
+	"github.com/drone/drone/store"
+	"github.com/drone/drone/store/datastore"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Store is a middleware function that initializes the Datastore and attaches to
+// the context of every http.Request.
+func Store(cli *cli.Context) gin.HandlerFunc {
+	v := setupStore(cli)
+	return func(c *gin.Context) {
+		store.ToContext(c, v)
+		c.Next()
+	}
+}
+
+// helper function to create the datastore from the CLI context.
+func setupStore(c *cli.Context) store.Store {
+	return datastore.New(
+		c.String("driver"),
+		c.String("datasource"),
+	)
+}

router/middleware/stream.go

@@ -0,0 +1,17 @@
+package middleware
+
+import (
+	"github.com/drone/drone/stream"
+
+	"github.com/codegangsta/cli"
+	"github.com/gin-gonic/gin"
+)
+
+// Stream is a middleware function that initializes the Stream and attaches to
+// the context of every http.Request.
+func Stream(cli *cli.Context) gin.HandlerFunc {
+	v := stream.New()
+	return func(c *gin.Context) {
+		stream.ToContext(c, v)
+	}
+}

router/middleware/version.go

@@ -0,0 +1,12 @@
+package middleware
+
+import (
+	"github.com/drone/drone/version"
+	"github.com/gin-gonic/gin"
+)
+
+// Version is a middleware function that appends the Drone version information
+// to the HTTP response. This is intended for debugging and troubleshooting.
+func Version(c *gin.Context) {
+	c.Header("X-DRONE-VERSION", version.Version)
+}