Add pusher

src/grafana/client.go

 		if resp.StatusCode == http.StatusNotFound {
 			err = fmt.Errorf("%s not found (404)", url)
 		} else {
-			err = fmt.Errorf(
-				"Unknown error: %d; body: %s",
-				resp.StatusCode,
-				string(respBody),
-			)
+			err = newHttpUnknownError(resp.StatusCode)
 		}
 	}
 
 	return respBody, err
 }
+
+type httpUnkownError struct {
+	StatusCode int
+}
+
+func newHttpUnknownError(statusCode int) *httpUnkownError {
+	return &httpUnkownError{
+		StatusCode: statusCode,
+	}
+}
+
+func (e *httpUnkownError) Error() string {
+	return fmt.Sprintf("Unknown HTTP error: %d", e.StatusCode)
+}

src/grafana/dashboards.go

 
 import (
 	"encoding/json"
+	"fmt"
 )
 
 type dbSearchResponse struct {
 	Starred bool     `json:"isStarred"`
 }
 
+type dbUpdateRequest struct {
+	Dashboard rawJSON `json:"dashboard"`
+	Overwrite bool    `json:"overwrite"`
+}
+
+type dbUpdateResponse struct {
+	Status  string `json:"success"`
+	Version int    `json:"version,omitempty"`
+	Message string `json:"message,omitempty"`
+}
+
 type Dashboard struct {
 	RawJSON []byte
 	Slug    string
 
 func (d *Dashboard) UnmarshalJSON(b []byte) (err error) {
 	var body struct {
-		Dashboard interface{} `json:"dashboard"`
+		Dashboard rawJSON `json:"dashboard"`
 		Meta      struct {
 			Slug    string `json:"slug"`
 			Version int    `json:"version"`
 	}
 	d.Slug = body.Meta.Slug
 	d.Version = body.Meta.Version
-	d.RawJSON, err = json.Marshal(body.Dashboard)
+	d.RawJSON = body.Dashboard
 
 	return
 }
 	err = json.Unmarshal(body, db)
 	return
 }
+
+func (c *Client) UpdateDashboard(slug string, contentJSON []byte) (err error) {
+	reqBody := dbUpdateRequest{
+		Dashboard: rawJSON(contentJSON),
+		Overwrite: false,
+	}
+
+	reqBodyJSON, err := json.Marshal(reqBody)
+	if err != nil {
+		return
+	}
+
+	var httpError *httpUnkownError
+	var isHttpUnknownError bool
+	respBodyJSON, err := c.request("POST", "dashboards/db", reqBodyJSON)
+	if err != nil {
+		httpError, isHttpUnknownError = err.(*httpUnkownError)
+		// We process httpUnkownError errors below, after we decoded the body
+		if !isHttpUnknownError {
+			return
+		}
+	}
+
+	var respBody dbUpdateResponse
+	if err = json.Unmarshal(respBodyJSON, &respBody); err != nil {
+		return
+	}
+
+	if respBody.Status != "success" && isHttpUnknownError {
+		return fmt.Errorf(
+			"Failed to update dashboard %s (%d %s): %s",
+			slug, httpError.StatusCode, respBody.Status, respBody.Message,
+		)
+	}
+
+	return
+}

src/grafana/json.go

+package grafana
+
+// Taken from https://github.com/matrix-org/gomatrixserverlib/blob/7d789f4fb6fa1624901abf391426c5560d76793f/redactevent.go#L39-L51
+type rawJSON []byte
+
+// MarshalJSON implements the json.Marshaller interface using a value receiver.
+// This means that rawJSON used as an embedded value will still encode correctly.
+func (r rawJSON) MarshalJSON() ([]byte, error) {
+	return []byte(r), nil
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface using a pointer receiver.
+func (r *rawJSON) UnmarshalJSON(data []byte) error {
+	*r = rawJSON(data)
+	return nil
+}

src/pusher/main.go

+package main
+
+import (
+	"flag"
+	"os"
+
+	"grafana"
+)
+
+// The Grafana API client needs to be global to the package since we need it in
+// the webhook handlers
+// TODO: Find a better way to pass it to the handlers
+var grafanaClient *grafana.Client
+
+var (
+	grafanaURL       = flag.String("grafana-url", "", "Base URL of the Grafana instance")
+	grafanaAPIKey    = flag.String("api-key", "", "API key to use in authenticated requests")
+	clonePath        = flag.String("clone-path", "/tmp/grafana-dashboards", "Path to directory where the repo will be cloned")
+	repoURL          = flag.String("git-repo", "", "SSH URL for the Git repository, without the user part")
+	privateKeyPath   = flag.String("private-key", "", "Path to the private key used to talk with the Git remote")
+	webhookInterface = flag.String("webhook-interface", "127.0.0.1", "Interface on which the GitLab webhook will be exposed")
+	webhookPort      = flag.Int("webhook-port", 8080, "Port on which the GitLab webhook will be exposed")
+	webhookPath      = flag.String("webhook-path", "/gitlab-webhook", "Path at which GitLab should send payloads to the webhook")
+	webhookSecret    = flag.String("webhook-secret", "", "Secret GitLab will use to send payloads to the webhook")
+)
+
+func main() {
+	flag.Parse()
+
+	if *grafanaURL == "" {
+		println("Error: No Grafana URL provided")
+		flag.Usage()
+		os.Exit(1)
+	}
+	if *grafanaAPIKey == "" {
+		println("Error: No Grafana API key provided")
+		flag.Usage()
+		os.Exit(1)
+	}
+	if *repoURL == "" {
+		println("Error: No Git repository provided")
+		flag.Usage()
+		os.Exit(1)
+	}
+	if *privateKeyPath == "" {
+		println("Error: No private key provided")
+		flag.Usage()
+		os.Exit(1)
+	}
+	if *webhookSecret == "" {
+		println("Error: No webhook secret provided")
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	grafanaClient = grafana.NewClient(*grafanaURL, *grafanaAPIKey)
+
+	if err := SetupWebhook(); err != nil {
+		panic(err)
+	}
+}

src/pusher/webhook.go

+package main
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/gitlab"
+)
+
+func SetupWebhook() error {
+	hook := gitlab.New(&gitlab.Config{
+		Secret: "mysecret",
+	})
+	hook.RegisterEvents(HandlePush, gitlab.PushEvents)
+
+	return webhooks.Run(
+		hook,
+		*webhookInterface+":"+strconv.Itoa(*webhookPort),
+		*webhookPath,
+	)
+}
+
+func HandlePush(payload interface{}, header webhooks.Header) {
+	pl := payload.(gitlab.PushEventPayload)
+
+	var err error
+	for _, commit := range pl.Commits {
+		for _, addedFile := range commit.Added {
+			if err = pushFile(addedFile); err != nil {
+				panic(err)
+			}
+		}
+
+		for _, modifiedFile := range commit.Modified {
+			if err = pushFile(modifiedFile); err != nil {
+				panic(err)
+			}
+		}
+
+		// TODO: Remove a dashboard when its file gets deleted?
+	}
+
+}
+
+func pushFile(filename string) error {
+	filePath := *clonePath + "/" + filename
+	fileContent, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
+
+	// Remove the .json part
+	slug := strings.Split(filename, ".json")[0]
+
+	return grafanaClient.UpdateDashboard(slug, fileContent)
+}

vendor/manifest

 			"branch": "v1"
 		},
 		{
+			"importpath": "gopkg.in/go-playground/webhooks.v3",
+			"repository": "https://gopkg.in/go-playground/webhooks.v3",
+			"revision": "ad5392160cf8f0bfc3be06bc469ce5dfa4cd77c4",
+			"branch": "master"
+		},
+		{
 			"importpath": "gopkg.in/src-d/go-billy.v3",
 			"repository": "https://gopkg.in/src-d/go-billy.v3",
 			"revision": "c329b7bc7b9d24905d2bc1b85bfa29f7ae266314",

vendor/src/gopkg.in/go-playground/webhooks.v3/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2015 Dean Karn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/src/gopkg.in/go-playground/webhooks.v3/README.md

+Library webhooks
+================
+<img align="right" src="https://raw.githubusercontent.com/go-playground/webhooks/v3/logo.png">![Project status](https://img.shields.io/badge/version-3.5.0-green.svg)
+[![Build Status](https://travis-ci.org/go-playground/webhooks.svg?branch=v3)](https://travis-ci.org/go-playground/webhooks)
+[![Coverage Status](https://coveralls.io/repos/go-playground/webhooks/badge.svg?branch=v3&service=github)](https://coveralls.io/github/go-playground/webhooks?branch=v3)
+[![Go Report Card](https://goreportcard.com/badge/go-playground/webhooks)](https://goreportcard.com/report/go-playground/webhooks)
+[![GoDoc](https://godoc.org/gopkg.in/go-playground/webhooks.v3?status.svg)](https://godoc.org/gopkg.in/go-playground/webhooks.v3)
+![License](https://img.shields.io/dub/l/vibe-d.svg)
+
+Library webhooks allows for easy receiving and parsing of GitHub, Bitbucket and GitLab Webhook Events
+
+Features:
+
+* Parses the entire payload, not just a few fields.
+* Fields + Schema directly lines up with webhook posted json
+
+Notes:
+
+* Currently only accepting json payloads.
+
+Installation
+------------
+
+Use go get.
+
+```shell
+	go get -u gopkg.in/go-playground/webhooks.v3
+```
+
+Then import the package into your own code.
+
+	import "gopkg.in/go-playground/webhooks.v3"
+
+Usage and Documentation
+------
+
+Please see http://godoc.org/gopkg.in/go-playground/webhooks.v3 for detailed usage docs.
+
+##### Examples:
+
+Multiple Handlers for each event you subscribe to
+```go
+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/github"
+)
+
+const (
+	path = "/webhooks"
+	port = 3016
+)
+
+func main() {
+
+	hook := github.New(&github.Config{Secret: "MyGitHubSuperSecretSecrect...?"})
+	hook.RegisterEvents(HandleRelease, github.ReleaseEvent)
+	hook.RegisterEvents(HandlePullRequest, github.PullRequestEvent)
+
+	err := webhooks.Run(hook, ":"+strconv.Itoa(port), path)
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+// HandleRelease handles GitHub release events
+func HandleRelease(payload interface{}, header webhooks.Header) {
+
+	fmt.Println("Handling Release")
+
+	pl := payload.(github.ReleasePayload)
+
+	// only want to compile on full releases
+	if pl.Release.Draft || pl.Release.Prerelease || pl.Release.TargetCommitish != "master" {
+		return
+	}
+
+	// Do whatever you want from here...
+	fmt.Printf("%+v", pl)
+}
+
+// HandlePullRequest handles GitHub pull_request events
+func HandlePullRequest(payload interface{}, header webhooks.Header) {
+
+	fmt.Println("Handling Pull Request")
+
+	pl := payload.(github.PullRequestPayload)
+
+	// Do whatever you want from here...
+	fmt.Printf("%+v", pl)
+}
+```
+
+Single receiver for events you subscribe to
+```go
+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/github"
+)
+
+const (
+	path = "/webhooks"
+	port = 3016
+)
+
+func main() {
+
+	hook := github.New(&github.Config{Secret: "MyGitHubSuperSecretSecrect...?"})
+	hook.RegisterEvents(HandleMultiple, github.ReleaseEvent, github.PullRequestEvent) // Add as many as you want
+
+	err := webhooks.Run(hook, ":"+strconv.Itoa(port), path)
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+// HandleMultiple handles multiple GitHub events
+func HandleMultiple(payload interface{}, header webhooks.Header) {
+
+	fmt.Println("Handling Payload..")
+
+	switch payload.(type) {
+
+	case github.ReleasePayload:
+		release := payload.(github.ReleasePayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", release)
+
+	case github.PullRequestPayload:
+		pullRequest := payload.(github.PullRequestPayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", pullRequest)
+	}
+}
+```
+
+Contributing
+------
+
+Pull requests for other services are welcome!
+
+If the changes being proposed or requested are breaking changes, please create an issue for discussion.
+
+License
+------
+Distributed under MIT License, please see license file in code for more details.

vendor/src/gopkg.in/go-playground/webhooks.v3/bitbucket/bitbucket.go

+package bitbucket
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"gopkg.in/go-playground/webhooks.v3"
+)
+
+// Webhook instance contains all methods needed to process events
+type Webhook struct {
+	provider   webhooks.Provider
+	uuid       string
+	eventFuncs map[Event]webhooks.ProcessPayloadFunc
+}
+
+// Config defines the configuration to create a new Bitbucket Webhook instance
+type Config struct {
+	UUID string
+}
+
+// Event defines a Bitbucket hook event type
+type Event string
+
+// Bitbucket hook types
+const (
+	RepoPushEvent                  Event = "repo:push"
+	RepoForkEvent                  Event = "repo:fork"
+	RepoUpdatedEvent               Event = "repo:updated"
+	RepoCommitCommentCreatedEvent  Event = "repo:commit_comment_created"
+	RepoCommitStatusCreatedEvent   Event = "repo:commit_status_created"
+	RepoCommitStatusUpdatedEvent   Event = "repo:commit_status_updated"
+	IssueCreatedEvent              Event = "issue:created"
+	IssueUpdatedEvent              Event = "issue:updated"
+	IssueCommentCreatedEvent       Event = "issue:comment_created"
+	PullRequestCreatedEvent        Event = "pullrequest:created"
+	PullRequestUpdatedEvent        Event = "pullrequest:updated"
+	PullRequestApprovedEvent       Event = "pullrequest:approved"
+	PullRequestUnapprovedEvent     Event = "pullrequest:unapproved"
+	PullRequestMergedEvent         Event = "pullrequest:fulfilled"
+	PullRequestDeclinedEvent       Event = "pullrequest:rejected"
+	PullRequestCommentCreatedEvent Event = "pullrequest:comment_created"
+	PullRequestCommentUpdatedEvent Event = "pullrequest:comment_updated"
+	PullRequestCommentDeletedEvent Event = "pull_request:comment_deleted"
+)
+
+// New creates and returns a WebHook instance denoted by the Provider type
+func New(config *Config) *Webhook {
+	return &Webhook{
+		provider:   webhooks.Bitbucket,
+		uuid:       config.UUID,
+		eventFuncs: map[Event]webhooks.ProcessPayloadFunc{},
+	}
+}
+
+// Provider returns the current hooks provider ID
+func (hook Webhook) Provider() webhooks.Provider {
+	return hook.provider
+}
+
+// RegisterEvents registers the function to call when the specified event(s) are encountered
+func (hook Webhook) RegisterEvents(fn webhooks.ProcessPayloadFunc, events ...Event) {
+
+	for _, event := range events {
+		hook.eventFuncs[event] = fn
+	}
+}
+
+// ParsePayload parses and verifies the payload and fires off the mapped function, if it exists.
+func (hook Webhook) ParsePayload(w http.ResponseWriter, r *http.Request) {
+	webhooks.DefaultLog.Info("Parsing Payload...")
+
+	uuid := r.Header.Get("X-Hook-UUID")
+	if uuid == "" {
+		webhooks.DefaultLog.Error("Missing X-Hook-UUID Header")
+		http.Error(w, "400 Bad Request - Missing X-Hook-UUID Header", http.StatusBadRequest)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("X-Hook-UUID:%s", uuid))
+
+	if uuid != hook.uuid {
+		webhooks.DefaultLog.Error(fmt.Sprintf("X-Hook-UUID does not match configured uuid of %s", hook.uuid))
+		http.Error(w, "403 Forbidden - X-Hook-UUID does not match", http.StatusForbidden)
+		return
+	}
+
+	event := r.Header.Get("X-Event-Key")
+	if event == "" {
+		webhooks.DefaultLog.Error("Missing X-Event-Key Header")
+		http.Error(w, "400 Bad Request - Missing X-Event-Key Header", http.StatusBadRequest)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("X-Event-Key:%s", event))
+
+	bitbucketEvent := Event(event)
+
+	fn, ok := hook.eventFuncs[bitbucketEvent]
+	// if no event registered
+	if !ok {
+		webhooks.DefaultLog.Info(fmt.Sprintf("Webhook Event %s not registered, it is recommended to setup only events in bitbucket that will be registered in the webhook to avoid unnecessary traffic and reduce potential attack vectors.", event))
+		return
+	}
+
+	payload, err := ioutil.ReadAll(r.Body)
+	if err != nil || len(payload) == 0 {
+		webhooks.DefaultLog.Error("Issue reading Payload")
+		http.Error(w, "Issue reading Payload", http.StatusInternalServerError)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("Payload:%s", string(payload)))
+	hd := webhooks.Header(r.Header)
+
+	switch bitbucketEvent {
+	case RepoPushEvent:
+		var pl RepoPushPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case RepoForkEvent:
+		var pl RepoForkPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case RepoUpdatedEvent:
+		var pl RepoUpdatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case RepoCommitCommentCreatedEvent:
+		var pl RepoCommitCommentCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case RepoCommitStatusCreatedEvent:
+		var pl RepoCommitStatusCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case RepoCommitStatusUpdatedEvent:
+		var pl RepoCommitStatusUpdatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case IssueCreatedEvent:
+		var pl IssueCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case IssueUpdatedEvent:
+		var pl IssueUpdatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case IssueCommentCreatedEvent:
+		var pl IssueCommentCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestCreatedEvent:
+		var pl PullRequestCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestUpdatedEvent:
+		var pl PullRequestUpdatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestApprovedEvent:
+		var pl PullRequestApprovedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestUnapprovedEvent:
+		var pl PullRequestUnapprovedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestMergedEvent:
+		var pl PullRequestMergedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestDeclinedEvent:
+		var pl PullRequestDeclinedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestCommentCreatedEvent:
+		var pl PullRequestCommentCreatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestCommentUpdatedEvent:
+		var pl PullRequestCommentUpdatedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	case PullRequestCommentDeletedEvent:
+		var pl PullRequestCommentDeletedPayload
+		json.Unmarshal([]byte(payload), &pl)
+		hook.runProcessPayloadFunc(fn, pl, hd)
+	}
+}
+
+func (hook Webhook) runProcessPayloadFunc(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+	go func(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+		fn(results, header)
+	}(fn, results, header)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/bitbucket/payload.go

+package bitbucket
+
+import "time"
+
+// RepoPushPayload is the Bitbucket repo:push payload
+type RepoPushPayload struct {
+	Actor      Owner      `json:"actor"`
+	Repository Repository `json:"repository"`
+	Push       struct {
+		Changes []struct {
+			New struct {
+				Type   string `json:"type"`
+				Name   string `json:"name"`
+				Target struct {
+					Type    string    `json:"type"`
+					Hash    string    `json:"hash"`
+					Author  Owner     `json:"author"`
+					Message string    `json:"message"`
+					Date    time.Time `json:"date"`
+					Parents []struct {
+						Type  string `json:"type"`
+						Hash  string `json:"hash"`
+						Links struct {
+							Self struct {
+								Href string `json:"href"`
+							} `json:"self"`
+							HTML struct {
+								Href string `json:"href"`
+							} `json:"html"`
+						} `json:"links"`
+					} `json:"parents"`
+					Links struct {
+						Self struct {
+							Href string `json:"href"`
+						} `json:"self"`
+						HTML struct {
+							Href string `json:"href"`
+						} `json:"html"`
+					} `json:"links"`
+				} `json:"target"`
+				Links struct {
+					Self struct {
+						Href string `json:"href"`
+					} `json:"self"`
+					Commits struct {
+						Href string `json:"href"`
+					} `json:"commits"`
+					HTML struct {
+						Href string `json:"href"`
+					} `json:"html"`
+				} `json:"links"`
+			} `json:"new"`
+			Old struct {
+				Type   string `json:"type"`
+				Name   string `json:"name"`
+				Target struct {
+					Type    string    `json:"type"`
+					Hash    string    `json:"hash"`
+					Author  Owner     `json:"author"`
+					Message string    `json:"message"`
+					Date    time.Time `json:"date"`
+					Parents []struct {
+						Type  string `json:"type"`
+						Hash  string `json:"hash"`
+						Links struct {
+							Self struct {
+								Href string `json:"href"`
+							} `json:"self"`
+							HTML struct {
+								Href string `json:"href"`
+							} `json:"html"`
+						} `json:"links"`
+					} `json:"parents"`
+					Links struct {
+						Self struct {
+							Href string `json:"href"`
+						} `json:"self"`
+						HTML struct {
+							Href string `json:"href"`
+						} `json:"html"`
+					} `json:"links"`
+				} `json:"target"`
+				Links struct {
+					Self struct {
+						Href string `json:"href"`
+					} `json:"self"`
+					Commits struct {
+						Href string `json:"href"`
+					} `json:"commits"`
+					HTML struct {
+						Href string `json:"href"`
+					} `json:"html"`
+				} `json:"links"`
+			} `json:"old"`
+			Links struct {
+				HTML struct {
+					Href string `json:"href"`
+				} `json:"html"`
+				Diff struct {
+					Href string `json:"href"`
+				} `json:"diff"`
+				Commits struct {
+					Href string `json:"href"`
+				} `json:"commits"`
+			} `json:"links"`
+			Created bool `json:"created"`
+			Forced  bool `json:"forced"`
+			Closed  bool `json:"closed"`
+			Commits []struct {
+				Hash    string `json:"hash"`
+				Type    string `json:"type"`
+				Message string `json:"message"`
+				Author  Owner  `json:"author"`
+				Links   struct {
+					Self struct {
+						Href string `json:"href"`
+					} `json:"self"`
+					HTML struct {
+						Href string `json:"href"`
+					} `json:"html"`
+				} `json:"links"`
+			} `json:"commits"`
+			Truncated bool `json:"truncated"`
+		} `json:"changes"`
+	} `json:"push"`
+}
+
+// RepoForkPayload is the Bitbucket repo:fork payload
+type RepoForkPayload struct {
+	Actor      Owner      `json:"actor"`
+	Repository Repository `json:"repository"`
+	Fork       Repository `json:"fork"`
+}
+
+// RepoUpdatedPayload is the Bitbucket repo:updated payload
+type RepoUpdatedPayload struct {
+	Actor      Owner      `json:"actor"`
+	Repository Repository `json:"repository"`
+	Changes    struct {
+		Name struct {
+			New string `json:"new"`
+			Old string `json:"old"`
+		} `json:"name"`
+		Website struct {
+			New string `json:"new"`
+			Old string `json:"old"`
+		} `json:"website"`
+		Language struct {
+			New string `json:"new"`
+			Old string `json:"old"`
+		} `json:"language"`
+		Links struct {
+			New struct {
+				Avatar struct {
+					Href string `json:"href"`
+				} `json:"avatar"`
+				Self struct {
+					Href string `json:"href"`
+				} `json:"self"`
+				HTML struct {
+					Href string `json:"href"`
+				} `json:"html"`
+			} `json:"new"`
+			Old struct {
+				Avatar struct {
+					Href string `json:"href"`
+				} `json:"avatar"`
+				Self struct {
+					Href string `json:"href"`
+				} `json:"self"`
+				HTML struct {
+					Href string `json:"href"`
+				} `json:"html"`
+			} `json:"old"`
+		} `json:"links"`
+		Description struct {
+			New string `json:"new"`
+			Old string `json:"old"`
+		} `json:"description"`
+		FullName struct {
+			New string `json:"new"`
+			Old string `json:"old"`
+		} `json:"full_name"`
+	} `json:"changes"`
+}
+
+// RepoCommitCommentCreatedPayload is the Bitbucket repo:commit_comment_created payload
+type RepoCommitCommentCreatedPayload struct {
+	Actor      Owner      `json:"actor"`
+	Comment    Comment    `json:"comment"`
+	Repository Repository `json:"repository"`
+	Commit     struct {
+		Hash string `json:"hash"`
+	} `json:"commit"`
+}
+
+// RepoCommitStatusCreatedPayload is the Bitbucket repo:commit_status_created payload
+type RepoCommitStatusCreatedPayload struct {
+	Actor        Owner      `json:"actor"`
+	Repository   Repository `json:"repository"`
+	CommitStatus struct {
+		Name        string    `json:"name"`
+		Description string    `json:"description"`
+		State       string    `json:"state"`
+		Key         string    `json:"key"`
+		URL         string    `json:"url"`
+		Type        string    `json:"type"`
+		CreatedOn   time.Time `json:"created_on"`
+		UpdatedOn   time.Time `json:"updated_on"`
+		Links       struct {
+			Commit struct {
+				Href string `json:"href"`
+			} `json:"commit"`
+			Self struct {
+				Href string `json:"href"`
+			} `json:"self"`
+		} `json:"links"`
+	} `json:"commit_status"`
+}
+
+// RepoCommitStatusUpdatedPayload is the Bitbucket repo:commit_status_updated payload
+type RepoCommitStatusUpdatedPayload struct {
+	Actor        Owner      `json:"actor"`
+	Repository   Repository `json:"repository"`
+	CommitStatus struct {
+		Name        string    `json:"name"`
+		Description string    `json:"description"`
+		State       string    `json:"state"`
+		Key         string    `json:"key"`
+		URL         string    `json:"url"`
+		Type        string    `json:"type"`
+		CreatedOn   time.Time `json:"created_on"`
+		UpdatedOn   time.Time `json:"updated_on"`
+		Links       struct {
+			Commit struct {
+				Href string `json:"href"`
+			} `json:"commit"`
+			Self struct {
+				Href string `json:"href"`
+			} `json:"self"`
+		} `json:"links"`
+	} `json:"commit_status"`
+}
+
+// IssueCreatedPayload is the Bitbucket issue:created payload
+type IssueCreatedPayload struct {
+	Actor      Owner      `json:"actor"`
+	Issue      Issue      `json:"issue"`
+	Repository Repository `json:"repository"`
+}
+
+// IssueUpdatedPayload is the Bitbucket issue:updated payload
+type IssueUpdatedPayload struct {
+	Actor      Owner      `json:"actor"`
+	Issue      Issue      `json:"issue"`
+	Repository Repository `json:"repository"`
+	Comment    Comment    `json:"comment"`
+	Changes    struct {
+		Status struct {
+			Old string `json:"old"`
+			New string `json:"new"`
+		} `json:"status"`
+	} `json:"changes"`
+}
+
+// IssueCommentCreatedPayload is the Bitbucket pullrequest:created payload
+type IssueCommentCreatedPayload struct {
+	Actor      Owner      `json:"actor"`
+	Repository Repository `json:"repository"`
+	Issue      Issue      `json:"issue"`
+	Comment    Comment    `json:"comment"`
+}
+
+// PullRequestCreatedPayload is the Bitbucket pullrequest:created payload
+type PullRequestCreatedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+}
+
+// PullRequestUpdatedPayload is the Bitbucket pullrequest:updated payload
+type PullRequestUpdatedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+}
+
+// PullRequestApprovedPayload is the Bitbucket pullrequest:approved payload
+type PullRequestApprovedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+	Approval    struct {
+		Date time.Time `json:"date"`
+		User Owner     `json:"user"`
+	} `json:"approval"`
+}
+
+// PullRequestUnapprovedPayload is the Bitbucket pullrequest:unapproved payload
+type PullRequestUnapprovedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+	Approval    struct {
+		Date time.Time `json:"date"`
+		User Owner     `json:"user"`
+	} `json:"approval"`
+}
+
+// PullRequestMergedPayload is the Bitbucket pullrequest:fulfilled payload
+type PullRequestMergedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+}
+
+// PullRequestDeclinedPayload is the Bitbucket pullrequest:rejected payload
+type PullRequestDeclinedPayload struct {
+	Actor       Owner       `json:"actor"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Repository  Repository  `json:"repository"`
+}
+
+// PullRequestCommentCreatedPayload is the Bitbucket pullrequest:comment_updated payload
+type PullRequestCommentCreatedPayload struct {
+	Actor       Owner       `json:"actor"`
+	Repository  Repository  `json:"repository"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Comment     Comment     `json:"comment"`
+}
+
+// PullRequestCommentUpdatedPayload is the Bitbucket pullrequest:comment_created payload
+type PullRequestCommentUpdatedPayload struct {
+	Actor       Owner       `json:"actor"`
+	Repository  Repository  `json:"repository"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Comment     Comment     `json:"comment"`
+}
+
+// PullRequestCommentDeletedPayload is the Bitbucket pullrequest:comment_deleted payload
+type PullRequestCommentDeletedPayload struct {
+	Actor       Owner       `json:"actor"`
+	Repository  Repository  `json:"repository"`
+	PullRequest PullRequest `json:"pullrequest"`
+	Comment     Comment     `json:"comment"`
+}
+
+// Owner is the common Bitbucket Owner Sub Entity
+type Owner struct {
+	Type        string `json:"type"`
+	Username    string `json:"username"`
+	DisplayName string `json:"display_name"`
+	UUID        string `json:"uuid"`
+	Links       struct {
+		Self struct {
+			Href string `json:"href"`
+		} `json:"self"`
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+		Avatar struct {
+			Href string `json:"href"`
+		} `json:"avatar"`
+	} `json:"links"`
+}
+
+// Repository is the common Bitbucket Repository Sub Entity
+type Repository struct {
+	Type  string `json:"type"`
+	Links struct {
+		Self struct {
+			Href string `json:"href"`
+		} `json:"self"`
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+		Avatar struct {
+			Href string `json:"href"`
+		} `json:"avatar"`
+	} `json:"links"`
+	UUID      string  `json:"uuid"`
+	Project   Project `json:"project"`
+	FullName  string  `json:"full_name"`
+	Name      string  `json:"name"`
+	Website   string  `json:"website"`
+	Owner     Owner   `json:"owner"`
+	Scm       string  `json:"scm"`
+	IsPrivate bool    `json:"is_private"`
+}
+
+// Project is the common Bitbucket Project Sub Entity
+type Project struct {
+	Type    string `json:"type"`
+	Project string `json:"project"`
+	UUID    string `json:"uuid"`
+	Links   struct {
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+		Avatar struct {
+			Href string `json:"href"`
+		} `json:"avatar"`
+	} `json:"links"`
+	Key string `json:"key"`
+}
+
+// Issue is the common Bitbucket Issue Sub Entity
+type Issue struct {
+	ID        int64  `json:"id"`
+	Component string `json:"component"`
+	Title     string `json:"title"`
+	Content   struct {
+		Raw    string `json:"raw"`
+		HTML   string `json:"html"`
+		Markup string `json:"markup"`
+	} `json:"content"`
+	Priority  string `json:"priority"`
+	State     string `json:"state"`
+	Type      string `json:"type"`
+	Milestone struct {
+		Name string `json:"name"`
+	} `json:"milestone"`
+	Version struct {
+		Name string `json:"name"`
+	} `json:"version"`
+	CreatedOn time.Time `json:"created_on"`
+	UpdatedOn time.Time `json:"updated_on"`
+	Links     struct {
+		Self struct {
+			Href string `json:"href"`
+		} `json:"self"`
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+	} `json:"links"`
+}
+
+// Comment is the common Bitbucket Comment Sub Entity
+type Comment struct {
+	ID     int64 `json:"id"`
+	Parent struct {
+		ID int64 `json:"id"`
+	} `json:"parent"`
+	Content struct {
+		Raw    string `json:"raw"`
+		HTML   string `json:"html"`
+		Markup string `json:"markup"`
+	} `json:"content"`
+	Inline struct {
+		Path string `json:"path"`
+		From *int64 `json:"from"`
+		To   int64  `json:"to"`
+	} `json:"inline"`
+	CreatedOn time.Time `json:"created_on"`
+	UpdatedOn time.Time `json:"updated_on"`
+	Links     struct {
+		Self struct {
+			Href string `json:"href"`
+		} `json:"self"`
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+	} `json:"links"`
+}
+
+// PullRequest is the common Bitbucket Pull Request Sub Entity
+type PullRequest struct {
+	ID          int64  `json:"id"`
+	Title       string `json:"title"`
+	Description string `json:"description"`
+	State       string `json:"state"`
+	Author      Owner  `json:"author"`
+	Source      struct {
+		Branch struct {
+			Name string `json:"name"`
+		} `json:"branch"`
+		Commit struct {
+			Hash string `json:"hash"`
+		} `json:"commit"`
+		Repository Repository `json:"repository"`
+	} `json:"source"`
+	Destination struct {
+		Branch struct {
+			Name string `json:"name"`
+		} `json:"branch"`
+		Commit struct {
+			Hash string `json:"hash"`
+		} `json:"commit"`
+		Repository Repository `json:"repository"`
+	} `json:"destination"`
+	MergeCommit struct {
+		Hash string `json:"hash"`
+	} `json:"merge_commit"`
+	Participants      []Owner   `json:"participants"`
+	Reviewers         []Owner   `json:"reviewers"`
+	CloseSourceBranch bool      `json:"close_source_branch"`
+	ClosedBy          Owner     `json:"closed_by"`
+	Reason            string    `json:"reason"`
+	CreatedOn         time.Time `json:"created_on"`
+	UpdatedOn         time.Time `json:"updated_on"`
+	Links             struct {
+		Self struct {
+			Href string `json:"href"`
+		} `json:"self"`
+		HTML struct {
+			Href string `json:"href"`
+		} `json:"html"`
+	} `json:"links"`
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/examples/custom-logger/main.go

+package main
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/github"
+)
+
+const (
+	path = "/webhooks"
+	port = 3016
+)
+
+type myLogger struct {
+	PrintDebugs bool
+}
+
+func (l *myLogger) Info(msg string) {
+	log.Println(msg)
+}
+
+func (l *myLogger) Error(msg string) {
+	log.Println(msg)
+}
+
+func (l *myLogger) Debug(msg string) {
+	if !l.PrintDebugs {
+		return
+	}
+	log.Println(msg)
+}
+
+func main() {
+	// webhooks.DefaultLog=webhooks.NewLogger(true)
+	//
+	// or override with your own
+	webhooks.DefaultLog = &myLogger{PrintDebugs: true}
+
+	hook := github.New(&github.Config{Secret: "MyGitHubSuperSecretSecrect...?"})
+	hook.RegisterEvents(HandleMultiple, github.ReleaseEvent, github.PullRequestEvent) // Add as many as you want
+
+	err := webhooks.Run(hook, ":"+strconv.Itoa(port), path)
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+// HandleMultiple handles multiple GitHub events
+func HandleMultiple(payload interface{}, header webhooks.Header) {
+	fmt.Println("Handling Payload..")
+
+	switch payload.(type) {
+
+	case github.ReleasePayload:
+		release := payload.(github.ReleasePayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", release)
+
+	case github.PullRequestPayload:
+		pullRequest := payload.(github.PullRequestPayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", pullRequest)
+	}
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/examples/multiple-handlers/main.go

+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/github"
+)
+
+const (
+	path = "/webhooks"
+	port = 3016
+)
+
+func main() {
+	hook := github.New(&github.Config{Secret: "MyGitHubSuperSecretSecrect...?"})
+	hook.RegisterEvents(HandleRelease, github.ReleaseEvent)
+	hook.RegisterEvents(HandlePullRequest, github.PullRequestEvent)
+
+	err := webhooks.Run(hook, ":"+strconv.Itoa(port), path)
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+// HandleRelease handles GitHub release events
+func HandleRelease(payload interface{}, header webhooks.Header) {
+	fmt.Println("Handling Release")
+
+	pl := payload.(github.ReleasePayload)
+
+	// only want to compile on full releases
+	if pl.Release.Draft || pl.Release.Prerelease || pl.Release.TargetCommitish != "master" {
+		return
+	}
+
+	// Do whatever you want from here...
+	fmt.Printf("%+v", pl)
+}
+
+// HandlePullRequest handles GitHub pull_request events
+func HandlePullRequest(payload interface{}, header webhooks.Header) {
+
+	fmt.Println("Handling Pull Request")
+
+	pl := payload.(github.PullRequestPayload)
+
+	// Do whatever you want from here...
+	fmt.Printf("%+v", pl)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/examples/single-handler/main.go

+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"gopkg.in/go-playground/webhooks.v3"
+	"gopkg.in/go-playground/webhooks.v3/github"
+)
+
+const (
+	path = "/webhooks"
+	port = 3016
+)
+
+func main() {
+	hook := github.New(&github.Config{Secret: "MyGitHubSuperSecretSecrect...?"})
+	hook.RegisterEvents(HandleMultiple, github.ReleaseEvent, github.PullRequestEvent) // Add as many as you want
+
+	err := webhooks.Run(hook, ":"+strconv.Itoa(port), path)
+	if err != nil {
+		fmt.Println(err)
+	}
+}
+
+// HandleMultiple handles multiple GitHub events
+func HandleMultiple(payload interface{}, header webhooks.Header) {
+	fmt.Println("Handling Payload..")
+
+	switch payload.(type) {
+
+	case github.ReleasePayload:
+		release := payload.(github.ReleasePayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", release)
+
+	case github.PullRequestPayload:
+		pullRequest := payload.(github.PullRequestPayload)
+		// Do whatever you want from here...
+		fmt.Printf("%+v", pullRequest)
+	}
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/github/github.go

+package github
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"gopkg.in/go-playground/webhooks.v3"
+)
+
+// Webhook instance contains all methods needed to process events
+type Webhook struct {
+	provider   webhooks.Provider
+	secret     string
+	eventFuncs map[Event]webhooks.ProcessPayloadFunc
+}
+
+// Config defines the configuration to create a new GitHub Webhook instance
+type Config struct {
+	Secret string
+}
+
+// Event defines a GitHub hook event type
+type Event string
+
+// GitHub hook types
+const (
+	CommitCommentEvent            Event = "commit_comment"
+	CreateEvent                   Event = "create"
+	DeleteEvent                   Event = "delete"
+	DeploymentEvent               Event = "deployment"
+	DeploymentStatusEvent         Event = "deployment_status"
+	ForkEvent                     Event = "fork"
+	GollumEvent                   Event = "gollum"
+	IssueCommentEvent             Event = "issue_comment"
+	IssuesEvent                   Event = "issues"
+	LabelEvent                    Event = "label"
+	MemberEvent                   Event = "member"
+	MembershipEvent               Event = "membership"
+	MilestoneEvent                Event = "milestone"
+	OrganizationEvent             Event = "organization"
+	OrgBlockEvent                 Event = "org_block"
+	PageBuildEvent                Event = "page_build"
+	ProjectCardEvent              Event = "project_card"
+	ProjectColumnEvent            Event = "project_column"
+	ProjectEvent                  Event = "project"
+	PublicEvent                   Event = "public"
+	PullRequestEvent              Event = "pull_request"
+	PullRequestReviewEvent        Event = "pull_request_review"
+	PullRequestReviewCommentEvent Event = "pull_request_review_comment"
+	PushEvent                     Event = "push"
+	ReleaseEvent                  Event = "release"
+	RepositoryEvent               Event = "repository"
+	StatusEvent                   Event = "status"
+	TeamEvent                     Event = "team"
+	TeamAddEvent                  Event = "team_add"
+	WatchEvent                    Event = "watch"
+)
+
+// EventSubtype defines a GitHub Hook Event subtype
+type EventSubtype string
+
+// GitHub hook event subtypes
+const (
+	NoSubtype     EventSubtype = ""
+	BranchSubtype EventSubtype = "branch"
+	TagSubtype    EventSubtype = "tag"
+	PullSubtype   EventSubtype = "pull"
+	IssueSubtype  EventSubtype = "issues"
+)
+
+// New creates and returns a WebHook instance denoted by the Provider type
+func New(config *Config) *Webhook {
+	return &Webhook{
+		provider:   webhooks.GitHub,
+		secret:     config.Secret,
+		eventFuncs: map[Event]webhooks.ProcessPayloadFunc{},
+	}
+}
+
+// Provider returns the current hooks provider ID
+func (hook Webhook) Provider() webhooks.Provider {
+	return hook.provider
+}
+
+// RegisterEvents registers the function to call when the specified event(s) are encountered
+func (hook Webhook) RegisterEvents(fn webhooks.ProcessPayloadFunc, events ...Event) {
+
+	for _, event := range events {
+		hook.eventFuncs[event] = fn
+	}
+}
+
+// ParsePayload parses and verifies the payload and fires off the mapped function, if it exists.
+func (hook Webhook) ParsePayload(w http.ResponseWriter, r *http.Request) {
+	webhooks.DefaultLog.Info("Parsing Payload...")
+
+	event := r.Header.Get("X-GitHub-Event")
+	if len(event) == 0 {
+		webhooks.DefaultLog.Error("Missing X-GitHub-Event Header")
+		http.Error(w, "400 Bad Request - Missing X-GitHub-Event Header", http.StatusBadRequest)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("X-GitHub-Event:%s", event))
+
+	gitHubEvent := Event(event)
+
+	fn, ok := hook.eventFuncs[gitHubEvent]
+	// if no event registered
+	if !ok {
+		webhooks.DefaultLog.Info(fmt.Sprintf("Webhook Event %s not registered, it is recommended to setup only events in github that will be registered in the webhook to avoid unnecessary traffic and reduce potential attack vectors.", event))
+		return
+	}
+
+	payload, err := ioutil.ReadAll(r.Body)
+	if err != nil || len(payload) == 0 {
+		webhooks.DefaultLog.Error("Issue reading Payload")
+		http.Error(w, "Issue reading Payload", http.StatusInternalServerError)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("Payload:%s", string(payload)))
+
+	// If we have a Secret set, we should check the MAC
+	if len(hook.secret) > 0 {
+		webhooks.DefaultLog.Info("Checking secret")
+		signature := r.Header.Get("X-Hub-Signature")
+		if len(signature) == 0 {
+			webhooks.DefaultLog.Error("Missing X-Hub-Signature required for HMAC verification")
+			http.Error(w, "403 Forbidden - Missing X-Hub-Signature required for HMAC verification", http.StatusForbidden)
+			return
+		}
+		webhooks.DefaultLog.Debug(fmt.Sprintf("X-Hub-Signature:%s", signature))
+
+		mac := hmac.New(sha1.New, []byte(hook.secret))
+		mac.Write(payload)
+
+		expectedMAC := hex.EncodeToString(mac.Sum(nil))
+
+		if !hmac.Equal([]byte(signature[5:]), []byte(expectedMAC)) {
+			webhooks.DefaultLog.Error("HMAC verification failed")
+			http.Error(w, "403 Forbidden - HMAC verification failed", http.StatusForbidden)
+			return
+		}
+	}
+
+	// Make headers available to ProcessPayloadFunc as a webhooks type
+	hd := webhooks.Header(r.Header)
+
+	switch gitHubEvent {
+	case CommitCommentEvent:
+		var cc CommitCommentPayload
+		json.Unmarshal([]byte(payload), &cc)
+		hook.runProcessPayloadFunc(fn, cc, hd)
+	case CreateEvent:
+		var c CreatePayload
+		json.Unmarshal([]byte(payload), &c)
+		hook.runProcessPayloadFunc(fn, c, hd)
+	case DeleteEvent:
+		var d DeletePayload
+		json.Unmarshal([]byte(payload), &d)
+		hook.runProcessPayloadFunc(fn, d, hd)
+	case DeploymentEvent:
+		var d DeploymentPayload
+		json.Unmarshal([]byte(payload), &d)
+		hook.runProcessPayloadFunc(fn, d, hd)
+	case DeploymentStatusEvent:
+		var d DeploymentStatusPayload
+		json.Unmarshal([]byte(payload), &d)
+		hook.runProcessPayloadFunc(fn, d, hd)
+	case ForkEvent:
+		var f ForkPayload
+		json.Unmarshal([]byte(payload), &f)
+		hook.runProcessPayloadFunc(fn, f, hd)
+	case GollumEvent:
+		var g GollumPayload
+		json.Unmarshal([]byte(payload), &g)
+		hook.runProcessPayloadFunc(fn, g, hd)
+	case IssueCommentEvent:
+		var i IssueCommentPayload
+		json.Unmarshal([]byte(payload), &i)
+		hook.runProcessPayloadFunc(fn, i, hd)
+	case IssuesEvent:
+		var i IssuesPayload
+		json.Unmarshal([]byte(payload), &i)
+		hook.runProcessPayloadFunc(fn, i, hd)
+	case LabelEvent:
+		var l LabelPayload
+		json.Unmarshal([]byte(payload), &l)
+		hook.runProcessPayloadFunc(fn, l, hd)
+	case MemberEvent:
+		var m MemberPayload
+		json.Unmarshal([]byte(payload), &m)
+		hook.runProcessPayloadFunc(fn, m, hd)
+	case MembershipEvent:
+		var m MembershipPayload
+		json.Unmarshal([]byte(payload), &m)
+		hook.runProcessPayloadFunc(fn, m, hd)
+	case MilestoneEvent:
+		var m MilestonePayload
+		json.Unmarshal([]byte(payload), &m)
+		hook.runProcessPayloadFunc(fn, m, hd)
+	case OrganizationEvent:
+		var o OrganizationPayload
+		json.Unmarshal([]byte(payload), &o)
+		hook.runProcessPayloadFunc(fn, o, hd)
+	case OrgBlockEvent:
+		var o OrgBlockPayload
+		json.Unmarshal([]byte(payload), &o)
+		hook.runProcessPayloadFunc(fn, o, hd)
+	case PageBuildEvent:
+		var p PageBuildPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case ProjectCardEvent:
+		var p ProjectCardPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case ProjectColumnEvent:
+		var p ProjectColumnPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case ProjectEvent:
+		var p ProjectPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case PublicEvent:
+		var p PublicPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case PullRequestEvent:
+		var p PullRequestPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case PullRequestReviewEvent:
+		var p PullRequestReviewPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case PullRequestReviewCommentEvent:
+		var p PullRequestReviewCommentPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case PushEvent:
+		var p PushPayload
+		json.Unmarshal([]byte(payload), &p)
+		hook.runProcessPayloadFunc(fn, p, hd)
+	case ReleaseEvent:
+		var r ReleasePayload
+		json.Unmarshal([]byte(payload), &r)
+		hook.runProcessPayloadFunc(fn, r, hd)
+	case RepositoryEvent:
+		var r RepositoryPayload
+		json.Unmarshal([]byte(payload), &r)
+		hook.runProcessPayloadFunc(fn, r, hd)
+	case StatusEvent:
+		var s StatusPayload
+		json.Unmarshal([]byte(payload), &s)
+		hook.runProcessPayloadFunc(fn, s, hd)
+	case TeamEvent:
+		var t TeamPayload
+		json.Unmarshal([]byte(payload), &t)
+		hook.runProcessPayloadFunc(fn, t, hd)
+	case TeamAddEvent:
+		var t TeamAddPayload
+		json.Unmarshal([]byte(payload), &t)
+		hook.runProcessPayloadFunc(fn, t, hd)
+	case WatchEvent:
+		var w WatchPayload
+		json.Unmarshal([]byte(payload), &w)
+		hook.runProcessPayloadFunc(fn, w, hd)
+	}
+}
+
+func (hook Webhook) runProcessPayloadFunc(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+	go func(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+		fn(results, header)
+	}(fn, results, header)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/gitlab/gitlab.go

+package gitlab
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"gopkg.in/go-playground/webhooks.v3"
+)
+
+// Webhook instance contains all methods needed to process events
+type Webhook struct {
+	provider   webhooks.Provider
+	secret     string
+	eventFuncs map[Event]webhooks.ProcessPayloadFunc
+}
+
+// Config defines the configuration to create a new GitHub Webhook instance
+type Config struct {
+	Secret string
+}
+
+// Event defines a GitHub hook event type
+type Event string
+
+// GitLab hook types
+const (
+	PushEvents               Event = "Push Hook"
+	TagEvents                Event = "Tag Push Hook"
+	IssuesEvents             Event = "Issue Hook"
+	ConfidentialIssuesEvents Event = "Confidential Issue Hook"
+	CommentEvents            Event = "Note Hook"
+	MergeRequestEvents       Event = "Merge Request Hook"
+	WikiPageEvents           Event = "Wiki Page Hook"
+	PipelineEvents           Event = "Pipeline Hook"
+	BuildEvents              Event = "Build Hook"
+)
+
+// New creates and returns a WebHook instance denoted by the Provider type
+func New(config *Config) *Webhook {
+	return &Webhook{
+		provider:   webhooks.GitLab,
+		secret:     config.Secret,
+		eventFuncs: map[Event]webhooks.ProcessPayloadFunc{},
+	}
+}
+
+// Provider returns the current hooks provider ID
+func (hook Webhook) Provider() webhooks.Provider {
+	return hook.provider
+}
+
+// RegisterEvents registers the function to call when the specified event(s) are encountered
+func (hook Webhook) RegisterEvents(fn webhooks.ProcessPayloadFunc, events ...Event) {
+
+	for _, event := range events {
+		hook.eventFuncs[event] = fn
+	}
+}
+
+// ParsePayload parses and verifies the payload and fires off the mapped function, if it exists.
+func (hook Webhook) ParsePayload(w http.ResponseWriter, r *http.Request) {
+	webhooks.DefaultLog.Info("Parsing Payload...")
+
+	event := r.Header.Get("X-Gitlab-Event")
+	if len(event) == 0 {
+		webhooks.DefaultLog.Error("Missing X-Gitlab-Event Header")
+		http.Error(w, "400 Bad Request - Missing X-Gitlab-Event Header", http.StatusBadRequest)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("X-Gitlab-Event:%s", event))
+
+	gitLabEvent := Event(event)
+
+	fn, ok := hook.eventFuncs[gitLabEvent]
+	// if no event registered
+	if !ok {
+		webhooks.DefaultLog.Info(fmt.Sprintf("Webhook Event %s not registered, it is recommended to setup only events in gitlab that will be registered in the webhook to avoid unnecessary traffic and reduce potential attack vectors.", event))
+		return
+	}
+
+	payload, err := ioutil.ReadAll(r.Body)
+	if err != nil || len(payload) == 0 {
+		webhooks.DefaultLog.Error("Issue reading Payload")
+		http.Error(w, "Error reading Payload", http.StatusInternalServerError)
+		return
+	}
+	webhooks.DefaultLog.Debug(fmt.Sprintf("Payload:%s", string(payload)))
+
+	// If we have a Secret set, we should check the MAC
+	if len(hook.secret) > 0 {
+		webhooks.DefaultLog.Info("Checking secret")
+		signature := r.Header.Get("X-Gitlab-Token")
+		if signature != hook.secret {
+			webhooks.DefaultLog.Error(fmt.Sprintf("Invalid X-Gitlab-Token of '%s'", signature))
+			http.Error(w, "403 Forbidden - Token missmatch", http.StatusForbidden)
+			return
+		}
+	}
+
+	// Make headers available to ProcessPayloadFunc as a webhooks type
+	hd := webhooks.Header(r.Header)
+
+	switch gitLabEvent {
+	case PushEvents:
+		var pe PushEventPayload
+		json.Unmarshal([]byte(payload), &pe)
+		hook.runProcessPayloadFunc(fn, pe, hd)
+
+	case TagEvents:
+		var te TagEventPayload
+		json.Unmarshal([]byte(payload), &te)
+		hook.runProcessPayloadFunc(fn, te, hd)
+
+	case ConfidentialIssuesEvents:
+		var cie ConfidentialIssueEventPayload
+		json.Unmarshal([]byte(payload), &cie)
+		hook.runProcessPayloadFunc(fn, cie, hd)
+
+	case IssuesEvents:
+		var ie IssueEventPayload
+		json.Unmarshal([]byte(payload), &ie)
+		hook.runProcessPayloadFunc(fn, ie, hd)
+
+	case CommentEvents:
+		var ce CommentEventPayload
+		json.Unmarshal([]byte(payload), &ce)
+		hook.runProcessPayloadFunc(fn, ce, hd)
+
+	case MergeRequestEvents:
+		var mre MergeRequestEventPayload
+		json.Unmarshal([]byte(payload), &mre)
+		hook.runProcessPayloadFunc(fn, mre, hd)
+
+	case WikiPageEvents:
+		var wpe WikiPageEventPayload
+		json.Unmarshal([]byte(payload), &wpe)
+		hook.runProcessPayloadFunc(fn, wpe, hd)
+
+	case PipelineEvents:
+		var pe PipelineEventPayload
+		json.Unmarshal([]byte(payload), &pe)
+		hook.runProcessPayloadFunc(fn, pe, hd)
+
+	case BuildEvents:
+		var be BuildEventPayload
+		json.Unmarshal([]byte(payload), &be)
+		hook.runProcessPayloadFunc(fn, be, hd)
+	}
+}
+
+func (hook Webhook) runProcessPayloadFunc(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+	go func(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
+		fn(results, header)
+	}(fn, results, header)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/gitlab/payload.go

+package gitlab
+
+import (
+	"strings"
+	"time"
+)
+
+type customTime struct {
+	time.Time
+}
+
+func (t *customTime) UnmarshalJSON(b []byte) (err error) {
+	layout := []string{
+		"2006-01-02 15:04:05 MST",
+		"2006-01-02 15:04:05 Z07:00",
+		"2006-01-02 15:04:05 Z0700",
+		time.RFC3339,
+	}
+	s := strings.Trim(string(b), "\"")
+	if s == "null" {
+		t.Time = time.Time{}
+		return
+	}
+	for _, l := range layout {
+		t.Time, err = time.Parse(l, s)
+		if err == nil {
+			break
+		}
+	}
+	return
+}
+
+// IssueEventPayload contains the information for GitLab's issue event
+type IssueEventPayload struct {
+	ObjectKind       string           `json:"object_kind"`
+	User             User             `json:"user"`
+	Project          Project          `json:"project"`
+	Repository       Repository       `json:"repository"`
+	ObjectAttributes ObjectAttributes `json:"object_attributes"`
+	Assignee         Assignee         `json:"assignee"`
+	Changes          Changes          `json:"changes"`
+}
+
+// ConfidentialIssueEventPayload contains the information for GitLab's confidential issue event
+type ConfidentialIssueEventPayload struct {
+	// The data for confidential issues is currently the same as normal issues,
+	// so we can just embed the normal issue payload type here.
+	IssueEventPayload
+}
+
+// MergeRequestEventPayload contains the information for GitLab's merge request event
+type MergeRequestEventPayload struct {
+	ObjectKind       string           `json:"object_kind"`
+	User             User             `json:"user"`
+	ObjectAttributes ObjectAttributes `json:"object_attributes"`
+	Changes          Changes          `json:"changes"`
+}
+
+// PushEventPayload contains the information for GitLab's push event
+type PushEventPayload struct {
+	ObjectKind        string     `json:"object_kind"`
+	Before            string     `json:"before"`
+	After             string     `json:"after"`
+	Ref               string     `json:"ref"`
+	CheckoutSHA       string     `json:"checkout_sha"`
+	UserID            int64      `json:"user_id"`
+	UserName          string     `json:"user_name"`
+	UserEmail         string     `json:"user_email"`
+	UserAvatar        string     `json:"user_avatar"`
+	ProjectID         int64      `json:"project_id"`
+	Project           Project    `json:"Project"`
+	Repository        Repository `json:"repository"`
+	Commits           []Commit   `json:"commits"`
+	TotalCommitsCount int64      `json:"total_commits_count"`
+}
+
+// TagEventPayload contains the information for GitLab's tag push event
+type TagEventPayload struct {
+	ObjectKind        string     `json:"object_kind"`
+	Before            string     `json:"before"`
+	After             string     `json:"after"`
+	Ref               string     `json:"ref"`
+	CheckoutSHA       string     `json:"checkout_sha"`
+	UserID            int64      `json:"user_id"`
+	UserName          string     `json:"user_name"`
+	UserAvatar        string     `json:"user_avatar"`
+	ProjectID         int64      `json:"project_id"`
+	Project           Project    `json:"Project"`
+	Repository        Repository `json:"repository"`
+	Commits           []Commit   `json:"commits"`
+	TotalCommitsCount int64      `json:"total_commits_count"`
+}
+
+// WikiPageEventPayload contains the information for GitLab's wiki created/updated event
+type WikiPageEventPayload struct {
+	ObjectKind       string           `json:"object_kind"`
+	User             User             `json:"user"`
+	Project          Project          `json:"project"`
+	Wiki             Wiki             `json:"wiki"`
+	ObjectAttributes ObjectAttributes `json:"object_attributes"`
+}
+
+// PipelineEventPayload contains the information for GitLab's pipeline status change event
+type PipelineEventPayload struct {
+	ObjectKind       string           `json:"object_kind"`
+	User             User             `json:"user"`
+	Project          Project          `json:"project"`
+	Commit           Commit           `json:"commit"`
+	ObjectAttributes ObjectAttributes `json:"object_attributes"`
+	Builds           []Build          `json:"builds"`
+}
+
+// CommentEventPayload contains the information for GitLab's comment event
+type CommentEventPayload struct {
+	ObjectKind       string           `json:"object_kind"`
+	User             User             `json:"user"`
+	ProjectID        int64            `json:"project_id"`
+	Project          Project          `json:"project"`
+	Repository       Repository       `json:"repository"`
+	ObjectAttributes ObjectAttributes `json:"object_attributes"`
+	MergeRequest     MergeRequest     `json:"merge_request"`
+	Commit           Commit           `json:"commit"`
+	Issue            Issue            `json:"issue"`
+	Snippet          Snippet          `json:"snippet"`
+}
+
+// BuildEventPayload contains the information for GitLab's build status change event
+type BuildEventPayload struct {
+	ObjectKind        string      `json:"object_kind"`
+	Ref               string      `json:"ref"`
+	Tag               bool        `json:"tag"`
+	BeforeSHA         string      `json:"before_sha"`
+	SHA               string      `json:"sha"`
+	BuildID           int64       `json:"build_id"`
+	BuildName         string      `json:"build_name"`
+	BuildStage        string      `json:"build_stage"`
+	BuildStatus       string      `json:"build_status"`
+	BuildStartedAt    customTime  `json:"build_started_at"`
+	BuildFinishedAt   customTime  `json:"build_finished_at"`
+	BuildDuration     int64       `json:"build_duration"`
+	BuildAllowFailure bool        `json:"build_allow_failure"`
+	ProjectID         int64       `json:"project_id"`
+	ProjectName       string      `json:"project_name"`
+	User              User        `json:"user"`
+	Commit            BuildCommit `json:"commit"`
+	Repository        Repository  `json:"repository"`
+}
+
+// Issue contains all of the GitLab issue information
+type Issue struct {
+	ID          int64      `json:"id"`
+	Title       string     `json:"title"`
+	AssigneeID  int64      `json:"assignee_id"`
+	AuthorID    int64      `json:"author_id"`
+	ProjectID   int64      `json:"project_id"`
+	CreatedAt   customTime `json:"created_at"`
+	UpdatedAt   customTime `json:"updated_at"`
+	Position    int64      `json:"position"`
+	BranchName  string     `json:"branch_name"`
+	Description string     `json:"description"`
+	MilestoneID int64      `json:"milestone_id"`
+	State       string     `json:"state"`
+	IID         int64      `json:"iid"`
+}
+
+// Build contains all of the GitLab build information
+type Build struct {
+	ID            int64         `json:"id"`
+	Stage         string        `json:"stage"`
+	Name          string        `json:"name"`
+	Status        string        `json:"status"`
+	CreatedAt     customTime    `json:"created_at"`
+	StartedAt     customTime    `json:"started_at"`
+	FinishedAt    customTime    `json:"finished_at"`
+	When          string        `json:"when"`
+	Manual        bool          `json:"manual"`
+	User          User          `json:"user"`
+	Runner        string        `json:"runner"`
+	ArtifactsFile ArtifactsFile `json:"artifactsfile"`
+}
+
+// ArtifactsFile contains all of the GitLab artifact information
+type ArtifactsFile struct {
+	Filename string `json:"filename"`
+	Size     string `json:"size"`
+}
+
+// Wiki contains all of the GitLab wiki information
+type Wiki struct {
+	WebURL            string `json:"web_url"`
+	GitSSHURL         string `json:"git_ssh_url"`
+	GitHTTPURL        string `json:"git_http_url"`
+	PathWithNamespace string `json:"path_with_namespace"`
+	DefaultBranch     string `json:"default_branch"`
+}
+
+// Commit contains all of the GitLab commit information
+type Commit struct {
+	ID        string     `json:"id"`
+	Message   string     `json:"message"`
+	Timestamp customTime `json:"timestamp"`
+	URL       string     `json:"url"`
+	Author    Author     `json:"author"`
+	Added     []string   `json:"added"`
+	Modified  []string   `json:"modified"`
+	Removed   []string   `json:"removed"`
+}
+
+// BuildCommit contains all of the GitLab build commit information
+type BuildCommit struct {
+	ID          int64      `json:"id"`
+	SHA         string     `json:"sha"`
+	Message     string     `json:"message"`
+	AuthorName  string     `json:"auuthor_name"`
+	AuthorEmail string     `json:"author_email"`
+	Status      string     `json:"status"`
+	Duration    int64      `json:"duration"`
+	StartedAt   customTime `json:"started_at"`
+	FinishedAt  customTime `json:"finished_at"`
+}
+
+// Snippet contains all of the GitLab snippet information
+type Snippet struct {
+	ID              int64      `json:"id"`
+	Title           string     `json:"title"`
+	Content         string     `json:"content"`
+	AuthorID        int64      `json:"author_id"`
+	ProjectID       int64      `json:"project_id"`
+	CreatedAt       customTime `json:"created_at"`
+	UpdatedAt       customTime `json:"updated_at"`
+	FileName        string     `json:"file_name"`
+	ExpiresAt       customTime `json:"expires_at"`
+	Type            string     `json:"type"`
+	VisibilityLevel int64      `json:"visibility_level"`
+}
+
+// User contains all of the GitLab user information
+type User struct {
+	Name      string `json:"name"`
+	UserName  string `json:"username"`
+	AvatarURL string `json:"avatar_url"`
+}
+
+// Project contains all of the GitLab project information
+type Project struct {
+	Name              string `json:"name"`
+	Description       string `json:"description"`
+	WebURL            string `json:"web_url"`
+	AvatarURL         string `json:"avatar_url"`
+	GitSSSHURL        string `json:"git_ssh_url"`
+	GitHTTPURL        string `json:"git_http_url"`
+	Namespace         string `json:"namespace"`
+	VisibilityLevel   int64  `json:"visibility_level"`
+	PathWithNamespace string `json:"path_with_namespace"`
+	DefaultBranch     string `json:"default_branch"`
+	Homepage          string `json:"homepage"`
+	URL               string `json:"url"`
+	SSHURL            string `json:"ssh_url"`
+	HTTPURL           string `json:"http_url"`
+}
+
+// Repository contains all of the GitLab repository information
+type Repository struct {
+	Name        string `json:"name"`
+	URL         string `json:"url"`
+	Description string `json:"description"`
+	Homepage    string `json:"homepage"`
+}
+
+// ObjectAttributes contains all of the GitLab object attributes information
+type ObjectAttributes struct {
+	ID              int64      `json:"id"`
+	Title           string     `json:"title"`
+	AssigneeID      int64      `json:"assignee_id"`
+	AuthorID        int64      `json:"author_id"`
+	ProjectID       int64      `json:"project_id"`
+	CreatedAt       customTime `json:"created_at"`
+	UpdatedAt       customTime `json:"updated_at"`
+	Position        int64      `json:"position"`
+	BranchName      string     `json:"branch_name"`
+	Description     string     `json:"description"`
+	MilestoneID     int64      `json:"milestone_id"`
+	State           string     `json:"state"`
+	IID             int64      `json:"iid"`
+	URL             string     `json:"url"`
+	Action          string     `json:"action"`
+	TargetBranch    string     `json:"target_branch"`
+	SourceBranch    string     `json:"source_branch"`
+	SourceProjectID int64      `json:"source_project_id"`
+	TargetProjectID int64      `json:"target_project_id"`
+	StCommits       string     `json:"st_commits"`
+	MergeStatus     string     `json:"merge_status"`
+	Content         string     `json:"content"`
+	Format          string     `json:"format"`
+	Message         string     `json:"message"`
+	Slug            string     `json:"slug"`
+	Ref             string     `json:"ref"`
+	Tag             bool       `json:"tag"`
+	SHA             string     `json:"sha"`
+	BeforeSHA       string     `json:"before_sha"`
+	Status          string     `json:"status"`
+	Stages          []string   `json:"stages"`
+	Duration        int64      `json:"duration"`
+	Note            string     `json:"note"`
+	NotebookType    string     `json:"noteable_type"`
+	At              customTime `json:"attachment"`
+	LineCode        string     `json:"line_code"`
+	CommitID        string     `json:"commit_id"`
+	NoteableID      int64      `json:"noteable_id"`
+	System          bool       `json:"system"`
+	WorkInProgress  bool       `json:"work_in_progress"`
+	StDiffs         []StDiff   `json:"st_diffs"`
+	Source          Source     `json:"source"`
+	Target          Target     `json:"target"`
+	LastCommit      LastCommit `json:"last_commit"`
+	Assignee        Assignee   `json:"assignee"`
+}
+
+// MergeRequest contains all of the GitLab merge request information
+type MergeRequest struct {
+	ID              int64      `json:"id"`
+	TargetBranch    string     `json:"target_branch"`
+	SourceBranch    string     `json:"source_branch"`
+	SourceProjectID int64      `json:"source_project_id"`
+	AssigneeID      int64      `json:"assignee_id"`
+	AuthorID        int64      `json:"author_id"`
+	Title           string     `json:"title"`
+	CreatedAt       customTime `json:"created_at"`
+	UpdatedAt       customTime `json:"updated_at"`
+	MilestoneID     int64      `json:"milestone_id"`
+	State           string     `json:"state"`
+	MergeStatus     string     `json:"merge_status"`
+	TargetProjectID int64      `json:"target_project_id"`
+	IID             int64      `json:"iid"`
+	Description     string     `json:"description"`
+	Position        int64      `json:"position"`
+	LockedAt        customTime `json:"locked_at"`
+	Source          Source     `json:"source"`
+	Target          Target     `json:"target"`
+	LastCommit      LastCommit `json:"last_commit"`
+	WorkInProgress  bool       `json:"work_in_progress"`
+	Assignee        Assignee   `json:"assignee"`
+}
+
+// Assignee contains all of the GitLab assignee information
+type Assignee struct {
+	Name      string `json:"name"`
+	Username  string `json:"username"`
+	AvatarURL string `json:"avatar_url"`
+}
+
+// StDiff contains all of the GitLab diff information
+type StDiff struct {
+	Diff        string `json:"diff"`
+	NewPath     string `json:"new_path"`
+	OldPath     string `json:"old_path"`
+	AMode       string `json:"a_mode"`
+	BMode       string `json:"b_mode"`
+	NewFile     bool   `json:"new_file"`
+	RenamedFile bool   `json:"renamed_file"`
+	DeletedFile bool   `json:"deleted_file"`
+}
+
+// Source contains all of the GitLab source information
+type Source struct {
+	Name              string `json:"name"`
+	Description       string `json:"description"`
+	WebURL            string `json:"web_url"`
+	AvatarURL         string `json:"avatar_url"`
+	GitSSHURL         string `json:"git_ssh_url"`
+	GitHTTPURL        string `json:"git_http_url"`
+	Namespace         string `json:"namespace"`
+	VisibilityLevel   int64  `json:"visibility_level"`
+	PathWithNamespace string `json:"path_with_namespace"`
+	DefaultBranch     string `json:"default_branch"`
+	Homepage          string `json:"homepage"`
+	URL               string `json:"url"`
+	SSHURL            string `json:"ssh_url"`
+	HTTPURL           string `json:"http_url"`
+}
+
+// Target contains all of the GitLab target information
+type Target struct {
+	Name              string `json:"name"`
+	Description       string `json:"description"`
+	WebURL            string `json:"web_url"`
+	AvatarURL         string `json:"avatar_url"`
+	GitSSHURL         string `json:"git_ssh_url"`
+	GitHTTPURL        string `json:"git_http_url"`
+	Namespace         string `json:"namespace"`
+	VisibilityLevel   int64  `json:"visibility_level"`
+	PathWithNamespace string `json:"path_with_namespace"`
+	DefaultBranch     string `json:"default_branch"`
+	Homepage          string `json:"homepage"`
+	URL               string `json:"url"`
+	SSHURL            string `json:"ssh_url"`
+	HTTPURL           string `json:"http_url"`
+}
+
+// LastCommit contains all of the GitLab last commit information
+type LastCommit struct {
+	ID        string     `json:"id"`
+	Message   string     `json:"message"`
+	Timestamp customTime `json:"timestamp"`
+	URL       string     `json:"url"`
+	Author    Author     `json:"author"`
+}
+
+// Author contains all of the GitLab author information
+type Author struct {
+	Name  string `json:"name"`
+	Email string `json:"email"`
+}
+
+// Changes contains all changes associated with a GitLab issue or MR
+type Changes struct {
+	LabelChanges LabelChanges `json:"labels"`
+}
+
+// LabelChanges contains changes in labels assocatiated with a GitLab issue or MR
+type LabelChanges struct {
+	Previous []Label `json:"previous"`
+	Current  []Label `json:"current"`
+}
+
+// Label contains all of the GitLab label information
+type Label struct {
+	Id          int64      `json:"id"`
+	Title       string     `json:"title"`
+	Color       string     `json:"color"`
+	ProjectId   int64      `json:"project_id"`
+	CreatedAt   customTime `json:"created_at"`
+	UpdatedAt   customTime `json:"updated_at"`
+	Template    bool       `json:"template"`
+	Description string     `json:"description"`
+	Type        string     `json:"type"`
+	GroupId     int64      `json:"group_id"`
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/logger.go

+package webhooks
+
+import "log"
+
+// DefaultLog contains the default logger for webhooks, and prints only info and error messages by default
+// for debugs override DefaultLog or see NewLogger for creating one without debugs.
+var DefaultLog Logger = new(logger)
+
+// Logger allows for customizable logging
+type Logger interface {
+	// Info prints basic information.
+	Info(string)
+	// Error prints error information.
+	Error(string)
+	// Debug prints information usefull for debugging.
+	Debug(string)
+}
+
+// NewLogger returns a new logger for use.
+func NewLogger(debug bool) Logger {
+	return &logger{PrintDebugs: debug}
+}
+
+type logger struct {
+	PrintDebugs bool
+}
+
+// Info prints basic information.
+func (l *logger) Info(msg string) {
+	log.Println("INFO:", msg)
+}
+
+// v prints error information.
+func (l *logger) Error(msg string) {
+	log.Println("ERROR:", msg)
+}
+
+// Debug prints information usefull for debugging.
+func (l *logger) Debug(msg string) {
+	if !l.PrintDebugs {
+		return
+	}
+	log.Println("DEBUG:", msg)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/webhooks.go

+package webhooks
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Header provides http.Header to minimize imports
+type Header http.Header
+
+// Provider defines the type of webhook
+type Provider int
+
+func (p Provider) String() string {
+	switch p {
+	case GitHub:
+		return "GitHub"
+	case Bitbucket:
+		return "Bitbucket"
+	case GitLab:
+		return "GitLab"
+	default:
+		return "Unknown"
+	}
+}
+
+// webhooks available providers
+const (
+	GitHub Provider = iota
+	Bitbucket
+	GitLab
+)
+
+// Webhook interface defines a webhook to receive events
+type Webhook interface {
+	Provider() Provider
+	ParsePayload(w http.ResponseWriter, r *http.Request)
+}
+
+type server struct {
+	hook             Webhook
+	path             string
+	includePathCheck bool
+}
+
+// ProcessPayloadFunc is a common function for payload return values
+type ProcessPayloadFunc func(payload interface{}, header Header)
+
+// Handler returns the webhook http.Handler for use in your own Mux implementation
+func Handler(hook Webhook) http.Handler {
+	return &server{
+		hook: hook,
+	}
+}
+
+// Run runs a server
+func Run(hook Webhook, addr string, path string) error {
+	srv := &server{
+		hook:             hook,
+		path:             path,
+		includePathCheck: true,
+	}
+	s := &http.Server{Addr: addr, Handler: srv}
+
+	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", addr, path))
+	return s.ListenAndServe()
+}
+
+// RunServer runs a custom server.
+func RunServer(s *http.Server, hook Webhook, path string) error {
+
+	srv := &server{
+		hook:             hook,
+		path:             path,
+		includePathCheck: true,
+	}
+
+	s.Handler = srv
+	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
+	return s.ListenAndServe()
+}
+
+// RunTLSServer runs a custom server with TLS configuration.
+// NOTE: http.Server Handler will be overridden by this library, just set it to nil.
+// Setting the Certificates can be done in the http.Server.TLSConfig.Certificates
+// see example here: https://github.com/go-playground/webhooks/blob/v2/webhooks_test.go#L178
+func RunTLSServer(s *http.Server, hook Webhook, path string) error {
+
+	srv := &server{
+		hook:             hook,
+		path:             path,
+		includePathCheck: true,
+	}
+
+	s.Handler = srv
+	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
+	return s.ListenAndServeTLS("", "")
+}
+
+// ServeHTTP is the Handler for every posted WebHook Event
+func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	defer r.Body.Close()
+	DefaultLog.Info("Webhook received")
+
+	if r.Method != "POST" {
+		DefaultLog.Error(fmt.Sprintf("405 Method not allowed, attempt made using Method: %s", r.Method))
+		http.Error(w, "405 Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	DefaultLog.Debug(fmt.Sprintf("Include path check: %t", s.includePathCheck))
+	if s.includePathCheck {
+		if r.URL.Path != s.path {
+			DefaultLog.Error(fmt.Sprintf("404 Not found, POST made using path: %s, but expected %s", r.URL.Path, s.path))
+			http.Error(w, "404 Not found", http.StatusNotFound)
+			return
+		}
+	}
+
+	s.hook.ParsePayload(w, r)
+}

vendor/src/gopkg.in/go-playground/webhooks.v3/webhooks_test.go

+package webhooks
+
+import (
+	"bytes"
+	"crypto/tls"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+
+	"net/http/httptest"
+
+	. "gopkg.in/go-playground/assert.v1"
+)
+
+// NOTES:
+// - Run "go test" to run tests
+// - Run "gocov test | gocov report" to report on test converage by file
+// - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called
+//
+// or
+//
+// -- may be a good idea to change to output path to somewherelike /tmp
+// go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
+//
+
+type FakeWebhook struct {
+	provider Provider
+}
+
+func (fhook FakeWebhook) Provider() Provider {
+	return fhook.provider
+}
+
+func (fhook FakeWebhook) ParsePayload(w http.ResponseWriter, r *http.Request) {
+}
+
+var fakeHook Webhook
+
+func TestMain(m *testing.M) {
+
+	// setup
+	fakeHook = &FakeWebhook{
+		provider: GitHub,
+	}
+
+	os.Exit(m.Run())
+
+	// teardown
+}
+
+func TestHandler(t *testing.T) {
+
+	mux := http.NewServeMux()
+	mux.Handle("/webhooks", Handler(fakeHook))
+
+	s := httptest.NewServer(Handler(fakeHook))
+	defer s.Close()
+
+	payload := "{}"
+
+	req, err := http.NewRequest("POST", s.URL+"/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusOK)
+
+	// Test BAD METHOD
+	req, err = http.NewRequest("GET", s.URL+"/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusMethodNotAllowed)
+}
+
+func TestRun(t *testing.T) {
+
+	go Run(fakeHook, "127.0.0.1:3006", "/webhooks")
+	time.Sleep(5000)
+
+	payload := "{}"
+
+	req, err := http.NewRequest("POST", "http://127.0.0.1:3006/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusOK)
+
+	// While HTTP Server is running test some bad input
+
+	// Test BAD URL
+	req, err = http.NewRequest("POST", "http://127.0.0.1:3006", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusNotFound)
+
+	// Test BAD METHOD
+	req, err = http.NewRequest("GET", "http://127.0.0.1:3006/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusMethodNotAllowed)
+}
+
+func TestRunServer(t *testing.T) {
+	DefaultLog = NewLogger(true)
+	server := &http.Server{Addr: "127.0.0.1:3007", Handler: nil}
+	go RunServer(server, fakeHook, "/webhooks")
+	time.Sleep(5000)
+
+	payload := "{}"
+
+	req, err := http.NewRequest("POST", "http://127.0.0.1:3007/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusOK)
+
+	// While HTTP Server is running test some bad input
+
+	// Test BAD URL
+	req, err = http.NewRequest("POST", "http://127.0.0.1:3007", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusNotFound)
+
+	// Test BAD METHOD
+	req, err = http.NewRequest("GET", "http://127.0.0.1:3007/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusMethodNotAllowed)
+}
+
+func TestRunTLSServer(t *testing.T) {
+
+	var err error
+
+	// can have certificates in static variables or load from disk
+	cert := `-----BEGIN CERTIFICATE-----
+MIIB0zCCAX2gAwIBAgIJAI/M7BYjwB+uMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMTIwOTEyMjE1MjAyWhcNMTUwOTEyMjE1MjAyWjBF
+MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANLJ
+hPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wok/4xIA+ui35/MmNa
+rtNuC+BdZ1tMuVCPFZcCAwEAAaNQME4wHQYDVR0OBBYEFJvKs8RfJaXTH08W+SGv
+zQyKn0H8MB8GA1UdIwQYMBaAFJvKs8RfJaXTH08W+SGvzQyKn0H8MAwGA1UdEwQF
+MAMBAf8wDQYJKoZIhvcNAQEFBQADQQBJlffJHybjDGxRMqaRmDhX0+6v02TUKZsW
+r5QuVbpQhH6u+0UgcW0jp9QwpxoPTLTWGXEWBBBurxFwiCBhkQ+V
+-----END CERTIFICATE-----
+    `
+	key := `-----BEGIN RSA PRIVATE KEY-----
+MIIBOwIBAAJBANLJhPHhITqQbPklG3ibCVxwGMRfp/v4XqhfdQHdcVfHap6NQ5Wo
+k/4xIA+ui35/MmNartNuC+BdZ1tMuVCPFZcCAwEAAQJAEJ2N+zsR0Xn8/Q6twa4G
+6OB1M1WO+k+ztnX/1SvNeWu8D6GImtupLTYgjZcHufykj09jiHmjHx8u8ZZB/o1N
+MQIhAPW+eyZo7ay3lMz1V01WVjNKK9QSn1MJlb06h/LuYv9FAiEA25WPedKgVyCW
+SmUwbPw8fnTcpqDWE3yTO3vKcebqMSsCIBF3UmVue8YU3jybC3NxuXq3wNm34R8T
+xVLHwDXh/6NJAiEAl2oHGGLz64BuAfjKrqwz7qMYr9HCLIe/YsoWq/olzScCIQDi
+D2lWusoe2/nEqfDVVWGWlyJ7yOmqaVm/iNUN9B2N2g==
+-----END RSA PRIVATE KEY-----
+`
+
+	server := &http.Server{Addr: "127.0.0.1:3008", Handler: nil, TLSConfig: &tls.Config{}}
+	server.TLSConfig.Certificates = make([]tls.Certificate, 1)
+
+	server.TLSConfig.Certificates[0], err = tls.X509KeyPair([]byte(cert), []byte(key))
+	Equal(t, err, nil)
+
+	go RunTLSServer(server, fakeHook, "/webhooks")
+	time.Sleep(5000)
+
+	payload := "{}"
+
+	req, err := http.NewRequest("POST", "https://127.0.0.1:3008/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+
+	client := &http.Client{Transport: tr}
+	resp, err := client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusOK)
+
+	// While HTTP Server is running test some bad input
+
+	// Test BAD URL
+	req, err = http.NewRequest("POST", "https://127.0.0.1:3008", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusNotFound)
+
+	// Test BAD METHOD
+	req, err = http.NewRequest("GET", "https://127.0.0.1:3008/webhooks", bytes.NewBuffer([]byte(payload)))
+	req.Header.Set("Content-Type", "application/json")
+
+	Equal(t, err, nil)
+
+	resp, err = client.Do(req)
+	Equal(t, err, nil)
+
+	defer resp.Body.Close()
+
+	Equal(t, resp.StatusCode, http.StatusMethodNotAllowed)
+}
+
+func TestProviderString(t *testing.T) {
+
+	Equal(t, GitHub.String(), "GitHub")
+	Equal(t, Bitbucket.String(), "Bitbucket")
+	Equal(t, GitLab.String(), "GitLab")
+	Equal(t, Provider(999999).String(), "Unknown")
+}