webhook.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623
  1. // Copyright 2014 The Gogs Authors. All rights reserved.
  2. // Use of this source code is governed by a MIT-style
  3. // license that can be found in the LICENSE file.
  4. package models
  5. import (
  6. "crypto/tls"
  7. "encoding/json"
  8. "fmt"
  9. "io/ioutil"
  10. "strings"
  11. "time"
  12. "github.com/go-xorm/xorm"
  13. gouuid "github.com/satori/go.uuid"
  14. log "gopkg.in/clog.v1"
  15. api "github.com/gogits/go-gogs-client"
  16. "github.com/gogits/gogs/modules/httplib"
  17. "github.com/gogits/gogs/modules/setting"
  18. "github.com/gogits/gogs/modules/sync"
  19. )
  20. var HookQueue = sync.NewUniqueQueue(setting.Webhook.QueueLength)
  21. type HookContentType int
  22. const (
  23. JSON HookContentType = iota + 1
  24. FORM
  25. )
  26. var hookContentTypes = map[string]HookContentType{
  27. "json": JSON,
  28. "form": FORM,
  29. }
  30. // ToHookContentType returns HookContentType by given name.
  31. func ToHookContentType(name string) HookContentType {
  32. return hookContentTypes[name]
  33. }
  34. func (t HookContentType) Name() string {
  35. switch t {
  36. case JSON:
  37. return "json"
  38. case FORM:
  39. return "form"
  40. }
  41. return ""
  42. }
  43. // IsValidHookContentType returns true if given name is a valid hook content type.
  44. func IsValidHookContentType(name string) bool {
  45. _, ok := hookContentTypes[name]
  46. return ok
  47. }
  48. type HookEvents struct {
  49. Create bool `json:"create"`
  50. Push bool `json:"push"`
  51. PullRequest bool `json:"pull_request"`
  52. }
  53. // HookEvent represents events that will delivery hook.
  54. type HookEvent struct {
  55. PushOnly bool `json:"push_only"`
  56. SendEverything bool `json:"send_everything"`
  57. ChooseEvents bool `json:"choose_events"`
  58. HookEvents `json:"events"`
  59. }
  60. type HookStatus int
  61. const (
  62. HOOK_STATUS_NONE = iota
  63. HOOK_STATUS_SUCCEED
  64. HOOK_STATUS_FAILED
  65. )
  66. // Webhook represents a web hook object.
  67. type Webhook struct {
  68. ID int64 `xorm:"pk autoincr"`
  69. RepoID int64
  70. OrgID int64
  71. URL string `xorm:"url TEXT"`
  72. ContentType HookContentType
  73. Secret string `xorm:"TEXT"`
  74. Events string `xorm:"TEXT"`
  75. *HookEvent `xorm:"-"`
  76. IsSSL bool `xorm:"is_ssl"`
  77. IsActive bool
  78. HookTaskType HookTaskType
  79. Meta string `xorm:"TEXT"` // store hook-specific attributes
  80. LastStatus HookStatus // Last delivery status
  81. Created time.Time `xorm:"-"`
  82. CreatedUnix int64
  83. Updated time.Time `xorm:"-"`
  84. UpdatedUnix int64
  85. }
  86. func (w *Webhook) BeforeInsert() {
  87. w.CreatedUnix = time.Now().Unix()
  88. w.UpdatedUnix = w.CreatedUnix
  89. }
  90. func (w *Webhook) BeforeUpdate() {
  91. w.UpdatedUnix = time.Now().Unix()
  92. }
  93. func (w *Webhook) AfterSet(colName string, _ xorm.Cell) {
  94. var err error
  95. switch colName {
  96. case "events":
  97. w.HookEvent = &HookEvent{}
  98. if err = json.Unmarshal([]byte(w.Events), w.HookEvent); err != nil {
  99. log.Error(3, "Unmarshal[%d]: %v", w.ID, err)
  100. }
  101. case "created_unix":
  102. w.Created = time.Unix(w.CreatedUnix, 0).Local()
  103. case "updated_unix":
  104. w.Updated = time.Unix(w.UpdatedUnix, 0).Local()
  105. }
  106. }
  107. func (w *Webhook) GetSlackHook() *SlackMeta {
  108. s := &SlackMeta{}
  109. if err := json.Unmarshal([]byte(w.Meta), s); err != nil {
  110. log.Error(4, "webhook.GetSlackHook(%d): %v", w.ID, err)
  111. }
  112. return s
  113. }
  114. // History returns history of webhook by given conditions.
  115. func (w *Webhook) History(page int) ([]*HookTask, error) {
  116. return HookTasks(w.ID, page)
  117. }
  118. // UpdateEvent handles conversion from HookEvent to Events.
  119. func (w *Webhook) UpdateEvent() error {
  120. data, err := json.Marshal(w.HookEvent)
  121. w.Events = string(data)
  122. return err
  123. }
  124. // HasCreateEvent returns true if hook enabled create event.
  125. func (w *Webhook) HasCreateEvent() bool {
  126. return w.SendEverything ||
  127. (w.ChooseEvents && w.HookEvents.Create)
  128. }
  129. // HasPushEvent returns true if hook enabled push event.
  130. func (w *Webhook) HasPushEvent() bool {
  131. return w.PushOnly || w.SendEverything ||
  132. (w.ChooseEvents && w.HookEvents.Push)
  133. }
  134. // HasPullRequestEvent returns true if hook enabled pull request event.
  135. func (w *Webhook) HasPullRequestEvent() bool {
  136. return w.SendEverything ||
  137. (w.ChooseEvents && w.HookEvents.PullRequest)
  138. }
  139. func (w *Webhook) EventsArray() []string {
  140. events := make([]string, 0, 3)
  141. if w.HasCreateEvent() {
  142. events = append(events, "create")
  143. }
  144. if w.HasPushEvent() {
  145. events = append(events, "push")
  146. }
  147. if w.HasPullRequestEvent() {
  148. events = append(events, "pull_request")
  149. }
  150. return events
  151. }
  152. // CreateWebhook creates a new web hook.
  153. func CreateWebhook(w *Webhook) error {
  154. _, err := x.Insert(w)
  155. return err
  156. }
  157. // getWebhook uses argument bean as query condition,
  158. // ID must be specified and do not assign unnecessary fields.
  159. func getWebhook(bean *Webhook) (*Webhook, error) {
  160. has, err := x.Get(bean)
  161. if err != nil {
  162. return nil, err
  163. } else if !has {
  164. return nil, ErrWebhookNotExist{bean.ID}
  165. }
  166. return bean, nil
  167. }
  168. // GetWebhookByRepoID returns webhook of repository by given ID.
  169. func GetWebhookByRepoID(repoID, id int64) (*Webhook, error) {
  170. return getWebhook(&Webhook{
  171. ID: id,
  172. RepoID: repoID,
  173. })
  174. }
  175. // GetWebhookByOrgID returns webhook of organization by given ID.
  176. func GetWebhookByOrgID(orgID, id int64) (*Webhook, error) {
  177. return getWebhook(&Webhook{
  178. ID: id,
  179. OrgID: orgID,
  180. })
  181. }
  182. // GetActiveWebhooksByRepoID returns all active webhooks of repository.
  183. func GetActiveWebhooksByRepoID(repoID int64) ([]*Webhook, error) {
  184. webhooks := make([]*Webhook, 0, 5)
  185. return webhooks, x.Where("repo_id = ?", repoID).And("is_active = ?", true).Find(&webhooks)
  186. }
  187. // GetWebhooksByRepoID returns all webhooks of a repository.
  188. func GetWebhooksByRepoID(repoID int64) ([]*Webhook, error) {
  189. webhooks := make([]*Webhook, 0, 5)
  190. return webhooks, x.Find(&webhooks, &Webhook{RepoID: repoID})
  191. }
  192. // UpdateWebhook updates information of webhook.
  193. func UpdateWebhook(w *Webhook) error {
  194. _, err := x.Id(w.ID).AllCols().Update(w)
  195. return err
  196. }
  197. // deleteWebhook uses argument bean as query condition,
  198. // ID must be specified and do not assign unnecessary fields.
  199. func deleteWebhook(bean *Webhook) (err error) {
  200. sess := x.NewSession()
  201. defer sessionRelease(sess)
  202. if err = sess.Begin(); err != nil {
  203. return err
  204. }
  205. if _, err = sess.Delete(bean); err != nil {
  206. return err
  207. } else if _, err = sess.Delete(&HookTask{HookID: bean.ID}); err != nil {
  208. return err
  209. }
  210. return sess.Commit()
  211. }
  212. // DeleteWebhookOfRepoByID deletes webhook of repository by given ID.
  213. func DeleteWebhookOfRepoByID(repoID, id int64) error {
  214. return deleteWebhook(&Webhook{
  215. ID: id,
  216. RepoID: repoID,
  217. })
  218. }
  219. // DeleteWebhookOfOrgByID deletes webhook of organization by given ID.
  220. func DeleteWebhookOfOrgByID(orgID, id int64) error {
  221. return deleteWebhook(&Webhook{
  222. ID: id,
  223. OrgID: orgID,
  224. })
  225. }
  226. // GetWebhooksByOrgID returns all webhooks for an organization.
  227. func GetWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) {
  228. err = x.Find(&ws, &Webhook{OrgID: orgID})
  229. return ws, err
  230. }
  231. // GetActiveWebhooksByOrgID returns all active webhooks for an organization.
  232. func GetActiveWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) {
  233. err = x.Where("org_id=?", orgID).And("is_active=?", true).Find(&ws)
  234. return ws, err
  235. }
  236. // ___ ___ __ ___________ __
  237. // / | \ ____ ____ | | _\__ ___/____ _____| | __
  238. // / ~ \/ _ \ / _ \| |/ / | | \__ \ / ___/ |/ /
  239. // \ Y ( <_> | <_> ) < | | / __ \_\___ \| <
  240. // \___|_ / \____/ \____/|__|_ \ |____| (____ /____ >__|_ \
  241. // \/ \/ \/ \/ \/
  242. type HookTaskType int
  243. const (
  244. GOGS HookTaskType = iota + 1
  245. SLACK
  246. DISCORD
  247. )
  248. var hookTaskTypes = map[string]HookTaskType{
  249. "gogs": GOGS,
  250. "slack": SLACK,
  251. }
  252. // ToHookTaskType returns HookTaskType by given name.
  253. func ToHookTaskType(name string) HookTaskType {
  254. return hookTaskTypes[name]
  255. }
  256. func (t HookTaskType) Name() string {
  257. switch t {
  258. case GOGS:
  259. return "gogs"
  260. case SLACK:
  261. return "slack"
  262. }
  263. return ""
  264. }
  265. // IsValidHookTaskType returns true if given name is a valid hook task type.
  266. func IsValidHookTaskType(name string) bool {
  267. _, ok := hookTaskTypes[name]
  268. return ok
  269. }
  270. type HookEventType string
  271. const (
  272. HOOK_EVENT_CREATE HookEventType = "create"
  273. HOOK_EVENT_PUSH HookEventType = "push"
  274. HOOK_EVENT_PULL_REQUEST HookEventType = "pull_request"
  275. )
  276. // HookRequest represents hook task request information.
  277. type HookRequest struct {
  278. Headers map[string]string `json:"headers"`
  279. }
  280. // HookResponse represents hook task response information.
  281. type HookResponse struct {
  282. Status int `json:"status"`
  283. Headers map[string]string `json:"headers"`
  284. Body string `json:"body"`
  285. }
  286. // HookTask represents a hook task.
  287. type HookTask struct {
  288. ID int64 `xorm:"pk autoincr"`
  289. RepoID int64 `xorm:"INDEX"`
  290. HookID int64
  291. UUID string
  292. Type HookTaskType
  293. URL string `xorm:"TEXT"`
  294. api.Payloader `xorm:"-"`
  295. PayloadContent string `xorm:"TEXT"`
  296. ContentType HookContentType
  297. EventType HookEventType
  298. IsSSL bool
  299. IsDelivered bool
  300. Delivered int64
  301. DeliveredString string `xorm:"-"`
  302. // History info.
  303. IsSucceed bool
  304. RequestContent string `xorm:"TEXT"`
  305. RequestInfo *HookRequest `xorm:"-"`
  306. ResponseContent string `xorm:"TEXT"`
  307. ResponseInfo *HookResponse `xorm:"-"`
  308. }
  309. func (t *HookTask) BeforeUpdate() {
  310. if t.RequestInfo != nil {
  311. t.RequestContent = t.MarshalJSON(t.RequestInfo)
  312. }
  313. if t.ResponseInfo != nil {
  314. t.ResponseContent = t.MarshalJSON(t.ResponseInfo)
  315. }
  316. }
  317. func (t *HookTask) AfterSet(colName string, _ xorm.Cell) {
  318. var err error
  319. switch colName {
  320. case "delivered":
  321. t.DeliveredString = time.Unix(0, t.Delivered).Format("2006-01-02 15:04:05 MST")
  322. case "request_content":
  323. if len(t.RequestContent) == 0 {
  324. return
  325. }
  326. t.RequestInfo = &HookRequest{}
  327. if err = json.Unmarshal([]byte(t.RequestContent), t.RequestInfo); err != nil {
  328. log.Error(3, "Unmarshal[%d]: %v", t.ID, err)
  329. }
  330. case "response_content":
  331. if len(t.ResponseContent) == 0 {
  332. return
  333. }
  334. t.ResponseInfo = &HookResponse{}
  335. if err = json.Unmarshal([]byte(t.ResponseContent), t.ResponseInfo); err != nil {
  336. log.Error(3, "Unmarshal [%d]: %v", t.ID, err)
  337. }
  338. }
  339. }
  340. func (t *HookTask) MarshalJSON(v interface{}) string {
  341. p, err := json.Marshal(v)
  342. if err != nil {
  343. log.Error(3, "Marshal [%d]: %v", t.ID, err)
  344. }
  345. return string(p)
  346. }
  347. // HookTasks returns a list of hook tasks by given conditions.
  348. func HookTasks(hookID int64, page int) ([]*HookTask, error) {
  349. tasks := make([]*HookTask, 0, setting.Webhook.PagingNum)
  350. return tasks, x.Limit(setting.Webhook.PagingNum, (page-1)*setting.Webhook.PagingNum).Where("hook_id=?", hookID).Desc("id").Find(&tasks)
  351. }
  352. // CreateHookTask creates a new hook task,
  353. // it handles conversion from Payload to PayloadContent.
  354. func CreateHookTask(t *HookTask) error {
  355. data, err := t.Payloader.JSONPayload()
  356. if err != nil {
  357. return err
  358. }
  359. t.UUID = gouuid.NewV4().String()
  360. t.PayloadContent = string(data)
  361. _, err = x.Insert(t)
  362. return err
  363. }
  364. // UpdateHookTask updates information of hook task.
  365. func UpdateHookTask(t *HookTask) error {
  366. _, err := x.Id(t.ID).AllCols().Update(t)
  367. return err
  368. }
  369. // PrepareWebhooks adds new webhooks to task queue for given payload.
  370. func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) error {
  371. ws, err := GetActiveWebhooksByRepoID(repo.ID)
  372. if err != nil {
  373. return fmt.Errorf("GetActiveWebhooksByRepoID: %v", err)
  374. }
  375. // check if repo belongs to org and append additional webhooks
  376. if repo.MustOwner().IsOrganization() {
  377. // get hooks for org
  378. orgws, err := GetActiveWebhooksByOrgID(repo.OwnerID)
  379. if err != nil {
  380. return fmt.Errorf("GetActiveWebhooksByOrgID: %v", err)
  381. }
  382. ws = append(ws, orgws...)
  383. }
  384. if len(ws) == 0 {
  385. return nil
  386. }
  387. var payloader api.Payloader
  388. for _, w := range ws {
  389. switch event {
  390. case HOOK_EVENT_CREATE:
  391. if !w.HasCreateEvent() {
  392. continue
  393. }
  394. case HOOK_EVENT_PUSH:
  395. if !w.HasPushEvent() {
  396. continue
  397. }
  398. case HOOK_EVENT_PULL_REQUEST:
  399. if !w.HasPullRequestEvent() {
  400. continue
  401. }
  402. }
  403. // Use separate objects so modifcations won't be made on payload on non-Gogs type hooks.
  404. switch w.HookTaskType {
  405. case SLACK:
  406. payloader, err = GetSlackPayload(p, event, w.Meta)
  407. if err != nil {
  408. return fmt.Errorf("GetSlackPayload: %v", err)
  409. }
  410. case DISCORD:
  411. payloader, err = GetDiscordPayload(p, event, w.Meta)
  412. if err != nil {
  413. return fmt.Errorf("GetDiscordPayload: %v", err)
  414. }
  415. default:
  416. p.SetSecret(w.Secret)
  417. payloader = p
  418. }
  419. if err = CreateHookTask(&HookTask{
  420. RepoID: repo.ID,
  421. HookID: w.ID,
  422. Type: w.HookTaskType,
  423. URL: w.URL,
  424. Payloader: payloader,
  425. ContentType: w.ContentType,
  426. EventType: event,
  427. IsSSL: w.IsSSL,
  428. }); err != nil {
  429. return fmt.Errorf("CreateHookTask: %v", err)
  430. }
  431. }
  432. return nil
  433. }
  434. func (t *HookTask) deliver() {
  435. t.IsDelivered = true
  436. timeout := time.Duration(setting.Webhook.DeliverTimeout) * time.Second
  437. req := httplib.Post(t.URL).SetTimeout(timeout, timeout).
  438. Header("X-Gogs-Delivery", t.UUID).
  439. Header("X-Gogs-Event", string(t.EventType)).
  440. SetTLSClientConfig(&tls.Config{InsecureSkipVerify: setting.Webhook.SkipTLSVerify})
  441. switch t.ContentType {
  442. case JSON:
  443. req = req.Header("Content-Type", "application/json").Body(t.PayloadContent)
  444. case FORM:
  445. req.Param("payload", t.PayloadContent)
  446. }
  447. // Record delivery information.
  448. t.RequestInfo = &HookRequest{
  449. Headers: map[string]string{},
  450. }
  451. for k, vals := range req.Headers() {
  452. t.RequestInfo.Headers[k] = strings.Join(vals, ",")
  453. }
  454. t.ResponseInfo = &HookResponse{
  455. Headers: map[string]string{},
  456. }
  457. defer func() {
  458. t.Delivered = time.Now().UnixNano()
  459. if t.IsSucceed {
  460. log.Trace("Hook delivered: %s", t.UUID)
  461. } else {
  462. log.Trace("Hook delivery failed: %s", t.UUID)
  463. }
  464. // Update webhook last delivery status.
  465. w, err := GetWebhookByRepoID(t.RepoID, t.HookID)
  466. if err != nil {
  467. log.Error(5, "GetWebhookByID: %v", err)
  468. return
  469. }
  470. if t.IsSucceed {
  471. w.LastStatus = HOOK_STATUS_SUCCEED
  472. } else {
  473. w.LastStatus = HOOK_STATUS_FAILED
  474. }
  475. if err = UpdateWebhook(w); err != nil {
  476. log.Error(5, "UpdateWebhook: %v", err)
  477. return
  478. }
  479. }()
  480. resp, err := req.Response()
  481. if err != nil {
  482. t.ResponseInfo.Body = fmt.Sprintf("Delivery: %v", err)
  483. return
  484. }
  485. defer resp.Body.Close()
  486. // Status code is 20x can be seen as succeed.
  487. t.IsSucceed = resp.StatusCode/100 == 2
  488. t.ResponseInfo.Status = resp.StatusCode
  489. for k, vals := range resp.Header {
  490. t.ResponseInfo.Headers[k] = strings.Join(vals, ",")
  491. }
  492. p, err := ioutil.ReadAll(resp.Body)
  493. if err != nil {
  494. t.ResponseInfo.Body = fmt.Sprintf("read body: %s", err)
  495. return
  496. }
  497. t.ResponseInfo.Body = string(p)
  498. }
  499. // DeliverHooks checks and delivers undelivered hooks.
  500. // TODO: shoot more hooks at same time.
  501. func DeliverHooks() {
  502. tasks := make([]*HookTask, 0, 10)
  503. x.Where("is_delivered=?", false).Iterate(new(HookTask),
  504. func(idx int, bean interface{}) error {
  505. t := bean.(*HookTask)
  506. t.deliver()
  507. tasks = append(tasks, t)
  508. return nil
  509. })
  510. // Update hook task status.
  511. for _, t := range tasks {
  512. if err := UpdateHookTask(t); err != nil {
  513. log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err)
  514. }
  515. }
  516. // Start listening on new hook requests.
  517. for repoID := range HookQueue.Queue() {
  518. log.Trace("DeliverHooks [repo_id: %v]", repoID)
  519. HookQueue.Remove(repoID)
  520. tasks = make([]*HookTask, 0, 5)
  521. if err := x.Where("repo_id=? AND is_delivered=?", repoID, false).Find(&tasks); err != nil {
  522. log.Error(4, "Get repository [%s] hook tasks: %v", repoID, err)
  523. continue
  524. }
  525. for _, t := range tasks {
  526. t.deliver()
  527. if err := UpdateHookTask(t); err != nil {
  528. log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err)
  529. continue
  530. }
  531. }
  532. }
  533. }
  534. func InitDeliverHooks() {
  535. go DeliverHooks()
  536. }