gitea/models/webhook.go

621 lines
15 KiB
Go
Raw Normal View History

2014-05-06 00:52:25 +00:00
// Copyright 2014 The Gogs Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package models
import (
"crypto/tls"
2014-05-06 00:52:25 +00:00
"encoding/json"
2015-08-27 15:06:14 +00:00
"fmt"
2014-08-24 12:59:47 +00:00
"io/ioutil"
2015-08-27 15:06:14 +00:00
"strings"
2014-06-08 08:45:34 +00:00
"time"
2014-05-06 00:52:25 +00:00
2015-08-27 15:06:14 +00:00
"github.com/go-xorm/xorm"
gouuid "github.com/satori/go.uuid"
2015-08-27 15:06:14 +00:00
api "github.com/go-gitea/go-sdk/gitea"
2015-08-28 15:36:13 +00:00
"github.com/go-gitea/gitea/modules/httplib"
"github.com/go-gitea/gitea/modules/log"
"github.com/go-gitea/gitea/modules/setting"
"github.com/go-gitea/gitea/modules/sync"
2014-05-06 00:52:25 +00:00
)
2016-08-30 22:50:30 +00:00
var HookQueue = sync.NewUniqueQueue(setting.Webhook.QueueLength)
2014-06-08 08:45:34 +00:00
type HookContentType int
2014-05-06 00:52:25 +00:00
const (
2016-11-07 16:53:22 +00:00
ContentTypeJson HookContentType = iota + 1
ContentTypeForm
2014-05-06 00:52:25 +00:00
)
2014-11-13 17:57:00 +00:00
var hookContentTypes = map[string]HookContentType{
2016-11-07 16:53:22 +00:00
"json": ContentTypeJson,
"form": ContentTypeForm,
2014-11-13 17:57:00 +00:00
}
// ToHookContentType returns HookContentType by given name.
func ToHookContentType(name string) HookContentType {
return hookContentTypes[name]
}
func (t HookContentType) Name() string {
switch t {
2016-11-07 16:53:22 +00:00
case ContentTypeJson:
return "json"
2016-11-07 16:53:22 +00:00
case ContentTypeForm:
return "form"
}
return ""
}
2014-11-13 17:57:00 +00:00
// IsValidHookContentType returns true if given name is a valid hook content type.
func IsValidHookContentType(name string) bool {
_, ok := hookContentTypes[name]
return ok
}
2015-08-28 15:36:13 +00:00
type HookEvents struct {
Create bool `json:"create"`
Push bool `json:"push"`
PullRequest bool `json:"pull_request"`
2015-08-28 15:36:13 +00:00
}
2014-06-08 08:45:34 +00:00
// HookEvent represents events that will delivery hook.
2014-05-06 00:52:25 +00:00
type HookEvent struct {
2015-08-28 15:36:13 +00:00
PushOnly bool `json:"push_only"`
SendEverything bool `json:"send_everything"`
ChooseEvents bool `json:"choose_events"`
HookEvents `json:"events"`
2014-05-06 00:52:25 +00:00
}
2015-08-26 13:45:51 +00:00
type HookStatus int
const (
2016-11-07 16:08:21 +00:00
HookStatusNone = iota
HookStatusSucceed
HookStatusFail
2015-08-26 13:45:51 +00:00
)
2014-06-08 08:45:34 +00:00
// Webhook represents a web hook object.
2014-05-06 00:52:25 +00:00
type Webhook struct {
2015-08-26 13:45:51 +00:00
ID int64 `xorm:"pk autoincr"`
RepoID int64
OrgID int64
URL string `xorm:"url TEXT"`
2014-08-24 12:59:47 +00:00
ContentType HookContentType
Secret string `xorm:"TEXT"`
Events string `xorm:"TEXT"`
*HookEvent `xorm:"-"`
2015-08-26 13:45:51 +00:00
IsSSL bool `xorm:"is_ssl"`
2014-08-24 12:59:47 +00:00
IsActive bool
HookTaskType HookTaskType
2015-08-26 13:45:51 +00:00
Meta string `xorm:"TEXT"` // store hook-specific attributes
LastStatus HookStatus // Last delivery status
Created time.Time `xorm:"-"`
CreatedUnix int64
Updated time.Time `xorm:"-"`
UpdatedUnix int64
}
func (w *Webhook) BeforeInsert() {
w.CreatedUnix = time.Now().Unix()
w.UpdatedUnix = w.CreatedUnix
}
func (w *Webhook) BeforeUpdate() {
w.UpdatedUnix = time.Now().Unix()
2014-05-06 00:52:25 +00:00
}
2015-08-29 03:49:59 +00:00
func (w *Webhook) AfterSet(colName string, _ xorm.Cell) {
var err error
switch colName {
case "events":
w.HookEvent = &HookEvent{}
if err = json.Unmarshal([]byte(w.Events), w.HookEvent); err != nil {
log.Error(3, "Unmarshal[%d]: %v", w.ID, err)
}
case "created_unix":
w.Created = time.Unix(w.CreatedUnix, 0).Local()
case "updated_unix":
w.Updated = time.Unix(w.UpdatedUnix, 0).Local()
2014-05-06 00:52:25 +00:00
}
}
2015-08-28 15:36:13 +00:00
func (w *Webhook) GetSlackHook() *SlackMeta {
s := &SlackMeta{}
2014-08-24 12:59:47 +00:00
if err := json.Unmarshal([]byte(w.Meta), s); err != nil {
2015-08-26 13:45:51 +00:00
log.Error(4, "webhook.GetSlackHook(%d): %v", w.ID, err)
2014-08-24 12:59:47 +00:00
}
return s
}
2015-08-27 15:06:14 +00:00
// History returns history of webhook by given conditions.
func (w *Webhook) History(page int) ([]*HookTask, error) {
return HookTasks(w.ID, page)
}
2014-06-08 08:54:52 +00:00
// UpdateEvent handles conversion from HookEvent to Events.
2014-06-08 08:45:34 +00:00
func (w *Webhook) UpdateEvent() error {
2014-05-06 01:36:08 +00:00
data, err := json.Marshal(w.HookEvent)
2014-05-06 00:52:25 +00:00
w.Events = string(data)
return err
}
2015-08-28 15:36:13 +00:00
// HasCreateEvent returns true if hook enabled create event.
func (w *Webhook) HasCreateEvent() bool {
return w.SendEverything ||
(w.ChooseEvents && w.HookEvents.Create)
}
2014-12-07 01:22:48 +00:00
// HasPushEvent returns true if hook enabled push event.
2014-05-06 15:50:31 +00:00
func (w *Webhook) HasPushEvent() bool {
2015-08-28 15:36:13 +00:00
return w.PushOnly || w.SendEverything ||
(w.ChooseEvents && w.HookEvents.Push)
2014-05-06 15:50:31 +00:00
}
// HasPullRequestEvent returns true if hook enabled pull request event.
func (w *Webhook) HasPullRequestEvent() bool {
return w.SendEverything ||
(w.ChooseEvents && w.HookEvents.PullRequest)
}
2015-08-29 03:49:59 +00:00
func (w *Webhook) EventsArray() []string {
events := make([]string, 0, 3)
2015-08-29 03:49:59 +00:00
if w.HasCreateEvent() {
events = append(events, "create")
}
if w.HasPushEvent() {
events = append(events, "push")
}
if w.HasPullRequestEvent() {
events = append(events, "pull_request")
}
2015-08-29 03:49:59 +00:00
return events
}
2014-06-08 08:45:34 +00:00
// CreateWebhook creates a new web hook.
2014-05-06 00:52:25 +00:00
func CreateWebhook(w *Webhook) error {
2014-06-21 04:51:41 +00:00
_, err := x.Insert(w)
2014-05-06 00:52:25 +00:00
return err
}
// getWebhook uses argument bean as query condition,
// ID must be specified and do not assign unnecessary fields.
func getWebhook(bean *Webhook) (*Webhook, error) {
has, err := x.Get(bean)
2014-05-06 01:36:08 +00:00
if err != nil {
return nil, err
} else if !has {
return nil, ErrWebhookNotExist{bean.ID}
2014-05-06 01:36:08 +00:00
}
return bean, nil
}
// GetWebhookByRepoID returns webhook of repository by given ID.
func GetWebhookByRepoID(repoID, id int64) (*Webhook, error) {
return getWebhook(&Webhook{
ID: id,
RepoID: repoID,
})
2014-05-06 01:36:08 +00:00
}
// GetWebhookByOrgID returns webhook of organization by given ID.
func GetWebhookByOrgID(orgID, id int64) (*Webhook, error) {
return getWebhook(&Webhook{
ID: id,
OrgID: orgID,
})
}
2015-08-28 15:36:13 +00:00
// GetActiveWebhooksByRepoID returns all active webhooks of repository.
2016-08-24 23:05:56 +00:00
func GetActiveWebhooksByRepoID(repoID int64) ([]*Webhook, error) {
webhooks := make([]*Webhook, 0, 5)
return webhooks, x.Find(&webhooks, &Webhook{
RepoID: repoID,
IsActive: true,
})
2014-05-06 15:50:31 +00:00
}
2016-08-24 23:05:56 +00:00
// GetWebhooksByRepoID returns all webhooks of a repository.
func GetWebhooksByRepoID(repoID int64) ([]*Webhook, error) {
webhooks := make([]*Webhook, 0, 5)
return webhooks, x.Find(&webhooks, &Webhook{RepoID: repoID})
2014-05-06 00:52:25 +00:00
}
2014-05-06 01:36:08 +00:00
2014-06-08 08:45:34 +00:00
// UpdateWebhook updates information of webhook.
func UpdateWebhook(w *Webhook) error {
2015-08-26 13:45:51 +00:00
_, err := x.Id(w.ID).AllCols().Update(w)
2014-06-08 08:45:34 +00:00
return err
}
// deleteWebhook uses argument bean as query condition,
// ID must be specified and do not assign unnecessary fields.
func deleteWebhook(bean *Webhook) (err error) {
2015-08-26 13:45:51 +00:00
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
return err
}
if _, err = sess.Delete(bean); err != nil {
2015-08-26 13:45:51 +00:00
return err
} else if _, err = sess.Delete(&HookTask{HookID: bean.ID}); err != nil {
2015-08-26 13:45:51 +00:00
return err
}
return sess.Commit()
2014-05-06 01:36:08 +00:00
}
2014-06-08 08:45:34 +00:00
// DeleteWebhookByRepoID deletes webhook of repository by given ID.
func DeleteWebhookByRepoID(repoID, id int64) error {
return deleteWebhook(&Webhook{
ID: id,
RepoID: repoID,
})
}
// DeleteWebhookByOrgID deletes webhook of organization by given ID.
func DeleteWebhookByOrgID(orgID, id int64) error {
return deleteWebhook(&Webhook{
ID: id,
OrgID: orgID,
})
}
// GetWebhooksByOrgID returns all webhooks for an organization.
func GetWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) {
2015-08-26 13:45:51 +00:00
err = x.Find(&ws, &Webhook{OrgID: orgID})
2014-09-04 11:17:00 +00:00
return ws, err
}
2015-08-28 15:36:13 +00:00
// GetActiveWebhooksByOrgID returns all active webhooks for an organization.
func GetActiveWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) {
err = x.Where("org_id=?", orgID).And("is_active=?", true).Find(&ws)
2014-09-04 11:17:00 +00:00
return ws, err
}
2014-06-08 08:45:34 +00:00
// ___ ___ __ ___________ __
// / | \ ____ ____ | | _\__ ___/____ _____| | __
// / ~ \/ _ \ / _ \| |/ / | | \__ \ / ___/ |/ /
// \ Y ( <_> | <_> ) < | | / __ \_\___ \| <
// \___|_ / \____/ \____/|__|_ \ |____| (____ /____ >__|_ \
// \/ \/ \/ \/ \/
type HookTaskType int
const (
2014-08-24 12:59:47 +00:00
GOGS HookTaskType = iota + 1
SLACK
2014-06-08 08:45:34 +00:00
)
2014-11-13 17:57:00 +00:00
var hookTaskTypes = map[string]HookTaskType{
"gogs": GOGS,
"slack": SLACK,
}
// ToHookTaskType returns HookTaskType by given name.
func ToHookTaskType(name string) HookTaskType {
return hookTaskTypes[name]
}
func (t HookTaskType) Name() string {
switch t {
case GOGS:
return "gogs"
case SLACK:
return "slack"
}
return ""
}
2014-11-13 17:57:00 +00:00
// IsValidHookTaskType returns true if given name is a valid hook task type.
func IsValidHookTaskType(name string) bool {
_, ok := hookTaskTypes[name]
return ok
}
2014-08-09 22:40:10 +00:00
type HookEventType string
const (
HookEventCreate HookEventType = "create"
HookEventPush HookEventType = "push"
HookEventPullRequest HookEventType = "pull_request"
2014-08-09 22:40:10 +00:00
)
2015-08-27 15:06:14 +00:00
// HookRequest represents hook task request information.
type HookRequest struct {
Headers map[string]string `json:"headers"`
}
// HookResponse represents hook task response information.
type HookResponse struct {
Status int `json:"status"`
Headers map[string]string `json:"headers"`
Body string `json:"body"`
}
2014-06-08 08:54:52 +00:00
// HookTask represents a hook task.
2014-06-08 08:45:34 +00:00
type HookTask struct {
2015-08-27 15:06:14 +00:00
ID int64 `xorm:"pk autoincr"`
RepoID int64 `xorm:"INDEX"`
HookID int64
UUID string
Type HookTaskType
2016-01-27 00:38:07 +00:00
URL string `xorm:"TEXT"`
2015-08-28 15:36:13 +00:00
api.Payloader `xorm:"-"`
2015-08-27 15:06:14 +00:00
PayloadContent string `xorm:"TEXT"`
ContentType HookContentType
EventType HookEventType
IsSSL bool
IsDelivered bool
Delivered int64
DeliveredString string `xorm:"-"`
// History info.
IsSucceed bool
RequestContent string `xorm:"TEXT"`
RequestInfo *HookRequest `xorm:"-"`
ResponseContent string `xorm:"TEXT"`
ResponseInfo *HookResponse `xorm:"-"`
}
func (t *HookTask) BeforeUpdate() {
if t.RequestInfo != nil {
t.RequestContent = t.SimpleMarshalJSON(t.RequestInfo)
2015-08-27 15:06:14 +00:00
}
if t.ResponseInfo != nil {
t.ResponseContent = t.SimpleMarshalJSON(t.ResponseInfo)
2015-08-27 15:06:14 +00:00
}
}
func (t *HookTask) AfterSet(colName string, _ xorm.Cell) {
var err error
switch colName {
case "delivered":
t.DeliveredString = time.Unix(0, t.Delivered).Format("2006-01-02 15:04:05 MST")
case "request_content":
if len(t.RequestContent) == 0 {
return
}
t.RequestInfo = &HookRequest{}
if err = json.Unmarshal([]byte(t.RequestContent), t.RequestInfo); err != nil {
log.Error(3, "Unmarshal[%d]: %v", t.ID, err)
}
case "response_content":
if len(t.ResponseContent) == 0 {
return
}
t.ResponseInfo = &HookResponse{}
if err = json.Unmarshal([]byte(t.ResponseContent), t.ResponseInfo); err != nil {
2015-12-05 18:24:13 +00:00
log.Error(3, "Unmarshal [%d]: %v", t.ID, err)
2015-08-27 15:06:14 +00:00
}
}
}
func (t *HookTask) SimpleMarshalJSON(v interface{}) string {
2015-08-27 15:06:14 +00:00
p, err := json.Marshal(v)
if err != nil {
2015-12-05 18:24:13 +00:00
log.Error(3, "Marshal [%d]: %v", t.ID, err)
2015-08-27 15:06:14 +00:00
}
return string(p)
}
// HookTasks returns a list of hook tasks by given conditions.
func HookTasks(hookID int64, page int) ([]*HookTask, error) {
tasks := make([]*HookTask, 0, setting.Webhook.PagingNum)
2015-08-28 15:36:13 +00:00
return tasks, x.Limit(setting.Webhook.PagingNum, (page-1)*setting.Webhook.PagingNum).Where("hook_id=?", hookID).Desc("id").Find(&tasks)
2014-06-08 08:45:34 +00:00
}
// CreateHookTask creates a new hook task,
// it handles conversion from Payload to PayloadContent.
func CreateHookTask(t *HookTask) error {
2015-08-28 15:36:13 +00:00
data, err := t.Payloader.JSONPayload()
2014-06-08 08:45:34 +00:00
if err != nil {
return err
}
t.UUID = gouuid.NewV4().String()
2014-06-08 08:45:34 +00:00
t.PayloadContent = string(data)
2014-06-21 04:51:41 +00:00
_, err = x.Insert(t)
2014-06-08 08:45:34 +00:00
return err
}
// UpdateHookTask updates information of hook task.
func UpdateHookTask(t *HookTask) error {
2015-07-25 13:32:04 +00:00
_, err := x.Id(t.ID).AllCols().Update(t)
2014-06-08 08:45:34 +00:00
return err
}
2015-08-28 15:36:13 +00:00
// PrepareWebhooks adds new webhooks to task queue for given payload.
func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) error {
ws, err := GetActiveWebhooksByRepoID(repo.ID)
if err != nil {
return fmt.Errorf("GetActiveWebhooksByRepoID: %v", err)
}
// check if repo belongs to org and append additional webhooks
if repo.MustOwner().IsOrganization() {
2015-08-28 15:36:13 +00:00
// get hooks for org
orgws, err := GetActiveWebhooksByOrgID(repo.OwnerID)
if err != nil {
return fmt.Errorf("GetActiveWebhooksByOrgID: %v", err)
}
ws = append(ws, orgws...)
}
if len(ws) == 0 {
return nil
}
var payloader api.Payloader
2015-08-28 15:36:13 +00:00
for _, w := range ws {
switch event {
case HookEventCreate:
2015-08-28 15:36:13 +00:00
if !w.HasCreateEvent() {
continue
}
case HookEventPush:
2015-08-28 15:36:13 +00:00
if !w.HasPushEvent() {
continue
}
case HookEventPullRequest:
if !w.HasPullRequestEvent() {
continue
}
2015-08-28 15:36:13 +00:00
}
// Use separate objects so modifcations won't be made on payload on non-Gogs type hooks.
2015-08-28 15:36:13 +00:00
switch w.HookTaskType {
case SLACK:
payloader, err = GetSlackPayload(p, event, w.Meta)
2015-08-28 15:36:13 +00:00
if err != nil {
return fmt.Errorf("GetSlackPayload: %v", err)
}
default:
p.SetSecret(w.Secret)
payloader = p
2015-08-28 15:36:13 +00:00
}
if err = CreateHookTask(&HookTask{
RepoID: repo.ID,
HookID: w.ID,
Type: w.HookTaskType,
URL: w.URL,
Payloader: payloader,
2015-08-28 15:36:13 +00:00
ContentType: w.ContentType,
EventType: event,
2015-08-28 15:36:13 +00:00
IsSSL: w.IsSSL,
}); err != nil {
return fmt.Errorf("CreateHookTask: %v", err)
}
}
return nil
}
func (t *HookTask) deliver() {
2015-08-27 15:06:14 +00:00
t.IsDelivered = true
timeout := time.Duration(setting.Webhook.DeliverTimeout) * time.Second
2015-08-27 15:06:14 +00:00
req := httplib.Post(t.URL).SetTimeout(timeout, timeout).
Header("X-Gogs-Delivery", t.UUID).
2015-07-25 13:32:04 +00:00
Header("X-Gogs-Event", string(t.EventType)).
SetTLSClientConfig(&tls.Config{InsecureSkipVerify: setting.Webhook.SkipTLSVerify})
2014-06-08 08:45:34 +00:00
2015-07-25 13:32:04 +00:00
switch t.ContentType {
2016-11-07 16:53:22 +00:00
case ContentTypeJson:
2015-07-25 13:32:04 +00:00
req = req.Header("Content-Type", "application/json").Body(t.PayloadContent)
2016-11-07 16:53:22 +00:00
case ContentTypeForm:
2015-07-25 13:32:04 +00:00
req.Param("payload", t.PayloadContent)
}
2014-08-09 22:40:10 +00:00
2015-08-27 15:06:14 +00:00
// Record delivery information.
t.RequestInfo = &HookRequest{
Headers: map[string]string{},
}
for k, vals := range req.Headers() {
t.RequestInfo.Headers[k] = strings.Join(vals, ",")
}
2015-07-25 13:32:04 +00:00
2015-08-27 15:06:14 +00:00
t.ResponseInfo = &HookResponse{
Headers: map[string]string{},
}
defer func() {
t.Delivered = time.Now().UnixNano()
2015-08-27 15:06:14 +00:00
if t.IsSucceed {
log.Trace("Hook delivered: %s", t.UUID)
2015-12-05 18:50:43 +00:00
} else {
log.Trace("Hook delivery failed: %s", t.UUID)
2015-07-25 13:32:04 +00:00
}
2015-08-27 15:06:14 +00:00
// Update webhook last delivery status.
w, err := GetWebhookByRepoID(t.RepoID, t.HookID)
2015-08-27 15:06:14 +00:00
if err != nil {
log.Error(5, "GetWebhookByID: %v", err)
return
}
if t.IsSucceed {
w.LastStatus = HookStatusSucceed
2015-08-27 15:06:14 +00:00
} else {
w.LastStatus = HookStatusFail
2015-07-25 13:32:04 +00:00
}
2015-08-27 15:06:14 +00:00
if err = UpdateWebhook(w); err != nil {
log.Error(5, "UpdateWebhook: %v", err)
return
}
}()
resp, err := req.Response()
if err != nil {
t.ResponseInfo.Body = fmt.Sprintf("Delivery: %v", err)
return
2015-07-25 13:32:04 +00:00
}
2015-08-27 15:06:14 +00:00
defer resp.Body.Close()
2014-08-09 22:40:10 +00:00
2015-08-27 15:06:14 +00:00
// Status code is 20x can be seen as succeed.
t.IsSucceed = resp.StatusCode/100 == 2
t.ResponseInfo.Status = resp.StatusCode
for k, vals := range resp.Header {
t.ResponseInfo.Headers[k] = strings.Join(vals, ",")
}
p, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.ResponseInfo.Body = fmt.Sprintf("read body: %s", err)
return
}
t.ResponseInfo.Body = string(p)
2015-07-25 13:32:04 +00:00
}
2014-06-08 08:45:34 +00:00
2015-07-25 13:32:04 +00:00
// DeliverHooks checks and delivers undelivered hooks.
// TODO: shoot more hooks at same time.
2015-07-25 13:32:04 +00:00
func DeliverHooks() {
tasks := make([]*HookTask, 0, 10)
x.Where("is_delivered=?", false).Iterate(new(HookTask),
func(idx int, bean interface{}) error {
t := bean.(*HookTask)
t.deliver()
2015-07-25 13:32:04 +00:00
tasks = append(tasks, t)
2014-06-08 08:45:34 +00:00
return nil
})
// Update hook task status.
for _, t := range tasks {
if err := UpdateHookTask(t); err != nil {
2015-12-05 18:24:13 +00:00
log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err)
2015-07-25 13:32:04 +00:00
}
}
// Start listening on new hook requests.
for repoID := range HookQueue.Queue() {
log.Trace("DeliverHooks [repo_id: %v]", repoID)
HookQueue.Remove(repoID)
2015-07-25 13:32:04 +00:00
tasks = make([]*HookTask, 0, 5)
if err := x.Where("repo_id=? AND is_delivered=?", repoID, false).Find(&tasks); err != nil {
2015-12-05 18:24:13 +00:00
log.Error(4, "Get repository [%d] hook tasks: %v", repoID, err)
2015-07-25 13:32:04 +00:00
continue
}
for _, t := range tasks {
t.deliver()
2015-07-25 13:32:04 +00:00
if err := UpdateHookTask(t); err != nil {
2015-12-05 18:24:13 +00:00
log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err)
continue
2015-07-25 13:32:04 +00:00
}
}
}
2014-06-08 08:45:34 +00:00
}
2015-07-25 13:32:04 +00:00
func InitDeliverHooks() {
go DeliverHooks()
}