func()

in prow/githubeventserver/githubeventserver.go [212:426]

• 192 lines of code
• 26 McCabe index (conditional complexity)

func (s *serveMuxHandler) handleEvent(eventType, eventGUID string, payload []byte, h http.Header) error {
	var org string
	var repo string

	l := logrus.WithFields(logrus.Fields{eventTypeField: eventType, github.EventGUID: eventGUID})

	// We don't want to fail the webhook due to a metrics error.
	if counter, err := s.metrics.WebhookCounter.GetMetricWithLabelValues(eventType); err != nil {
		l.WithError(err).Warn("Failed to get metric for eventType " + eventType)
	} else {
		counter.Inc()
	}

	switch eventType {
	case issuesEvent:
		var i github.IssueEvent
		if err := json.Unmarshal(payload, &i); err != nil {
			return err
		}
		i.GUID = eventGUID
		org = i.Repo.Owner.Login
		repo = i.Repo.Name

		for _, issueEventHandler := range s.issueEventHandlers {
			fn := issueEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  i.Repo.Owner.Login,
					github.RepoLogField: i.Repo.Name,
					github.PrLogField:   i.Issue.Number,
					"author":            i.Issue.User.Login,
					"url":               i.Issue.HTMLURL,
				}), i)
			}()
		}

	case issueCommentEvent:
		var ic github.IssueCommentEvent
		if err := json.Unmarshal(payload, &ic); err != nil {
			return err
		}
		ic.GUID = eventGUID
		org = ic.Repo.Owner.Login
		repo = ic.Repo.Name

		for _, issueCommentEventHandler := range s.issueCommentEventHandlers {
			fn := issueCommentEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  ic.Repo.Owner.Login,
					github.RepoLogField: ic.Repo.Name,
					github.PrLogField:   ic.Issue.Number,
					"author":            ic.Comment.User.Login,
					"url":               ic.Comment.HTMLURL,
				}), ic)
			}()
		}

	case pullRequestEvent:
		var pr github.PullRequestEvent
		if err := json.Unmarshal(payload, &pr); err != nil {
			return err
		}
		pr.GUID = eventGUID
		org = pr.Repo.Owner.Login
		repo = pr.Repo.Name

		for _, pullRequestHandler := range s.pullRequestHandlers {
			fn := pullRequestHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  pr.Repo.Owner.Login,
					github.RepoLogField: pr.Repo.Name,
					github.PrLogField:   pr.Number,
					"author":            pr.PullRequest.User.Login,
					"url":               pr.PullRequest.HTMLURL,
				}), pr)
			}()
		}

	case pullRequestReviewEvent:
		var re github.ReviewEvent
		if err := json.Unmarshal(payload, &re); err != nil {
			return err
		}
		re.GUID = eventGUID
		org = re.Repo.Owner.Login
		repo = re.Repo.Name

		for _, reviewEventHandler := range s.reviewEventHandlers {
			fn := reviewEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  re.Repo.Owner.Login,
					github.RepoLogField: re.Repo.Name,
					github.PrLogField:   re.PullRequest.Number,
					"review":            re.Review.ID,
					"reviewer":          re.Review.User.Login,
					"url":               re.Review.HTMLURL,
				}), re)
			}()
		}

	case pullRequestReviewCommentEvent:
		var rce github.ReviewCommentEvent
		if err := json.Unmarshal(payload, &rce); err != nil {
			return err
		}
		rce.GUID = eventGUID
		org = rce.Repo.Owner.Login
		repo = rce.Repo.Name

		for _, reviewCommentEventHandler := range s.reviewCommentEventHandlers {
			fn := reviewCommentEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  rce.Repo.Owner.Login,
					github.RepoLogField: rce.Repo.Name,
					github.PrLogField:   rce.PullRequest.Number,
					"review":            rce.Comment.ReviewID,
					"commenter":         rce.Comment.User.Login,
					"url":               rce.Comment.HTMLURL,
				}), rce)
			}()
		}

	case pushEvent:
		var pe github.PushEvent
		if err := json.Unmarshal(payload, &pe); err != nil {
			return err
		}
		pe.GUID = eventGUID
		org = pe.Repo.Owner.Login
		repo = pe.Repo.Name

		for _, pushEventHandler := range s.pushEventHandlers {
			fn := pushEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  pe.Repo.Owner.Name,
					github.RepoLogField: pe.Repo.Name,
					"ref":               pe.Ref,
					"head":              pe.After,
				}), pe)
			}()
		}

	case statusEvent:
		var se github.StatusEvent
		if err := json.Unmarshal(payload, &se); err != nil {
			return err
		}
		se.GUID = eventGUID
		org = se.Repo.Owner.Login
		repo = se.Repo.Name

		for _, statusEventHandler := range s.statusEventHandlers {
			fn := statusEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  se.Repo.Owner.Login,
					github.RepoLogField: se.Repo.Name,
					"context":           se.Context,
					"sha":               se.SHA,
					"state":             se.State,
					"id":                se.ID,
				}), se)
			}()
		}

	case workflowRunEvent:
		var wre github.WorkflowRunEvent
		if err := json.Unmarshal(payload, &wre); err != nil {
			return err
		}
		wre.GUID = eventGUID
		org = wre.Repo.Owner.Login
		repo = wre.Repo.Name

		for _, workflowRunEventHandler := range s.workflowRunEventHandler {
			fn := workflowRunEventHandler
			s.wg.Add(1)
			go func() {
				defer s.wg.Done()
				fn(l.WithFields(logrus.Fields{
					github.OrgLogField:  wre.Repo.Owner.Login,
					github.RepoLogField: wre.Repo.Name,
					"workflow_id":       wre.WorkflowRun.WorkflowID,
				}), wre)
			}()
		}

	default:
		l.Debug("Ignoring unhandled event type.")
	}

	// Redirect event to external plugins if necessary
	s.demuxExternal(l, s.getExternalPluginsForEvent(org, repo, eventType), payload, h, s.wg)

	return nil
}