Beispiel #1
0
func findEmail(c *githubAPI.Client, username string) string {
	events, resp, err := c.Activity.ListEventsPerformedByUser(username, true, nil)
	if err != nil {
		log.Println(kv.FormatLog("who-is-who", kayvee.Error, "Github API error", m{
			"msg": err.Error(),
		}))
		return ""
	} else if resp.StatusCode != http.StatusOK {
		log.Println(kv.FormatLog("who-is-who", kayvee.Error, "Github API error", m{
			"status code": resp.StatusCode,
		}))
		return ""
	}

	for _, e := range events {
		if e.RawPayload != nil {
			matches := emailRgx.FindAllStringSubmatch(string(*e.RawPayload), 1)
			if len(matches) == 1 && len(matches[0]) == 2 {
				return strings.ToLower(matches[0][1])
			}
		}
	}

	return ""
}
Beispiel #2
0
func main() {
	setupEnvVars()

	// setup dynamodb connection
	c, err := integrations.NewClient(dynamoTable, dynamoEndpoint, dynamoRegion, awsKey, awsSecret)
	if err != nil {
		log.Fatal(kv.FormatLog("who-is-who", kv.Error, "dynamo connection", m{
			"message": err.Error(),
		}))
	}
	d := api.DynamoConn{
		Dynamo: c,
	}

	// setup HTTP server
	log.Println(kv.FormatLog("who-is-who", kv.Info, "server startup", m{
		"message": fmt.Sprintf("Listening on %s", port),
	}))
	err = http.ListenAndServe(port, d.HookUpRouter())
	if err != nil {
		log.Fatal(kv.FormatLog("who-is-who", kv.Error, "server startup failure", m{
			"msg": err.Error(),
		}))
	}
}
Beispiel #3
0
func TestLogCritical(t *testing.T) {
	buf := &bytes.Buffer{}
	logger := New("logger-tester")
	logger.SetOutput(buf)
	logger.Critical("testlogcritical")
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Critical, "testlogcritical", map[string]interface{}{}))
	buf.Reset()
	logger.CriticalD("testlogcritical", map[string]interface{}{"key1": "val1", "key2": "val2"})
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Critical, "testlogcritical", map[string]interface{}{"key1": "val1", "key2": "val2"}))
}
Beispiel #4
0
func TestLogGaugeFloat(t *testing.T) {
	buf := &bytes.Buffer{}
	logger := New("logger-tester")
	logger.SetOutput(buf)
	logger.GaugeFloat("testloggauge", 0.0)
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Info, "testloggauge", map[string]interface{}{"type": "gauge", "value": 0.0}))
	buf.Reset()
	logger.GaugeFloatD("testloggauge", 4.0, map[string]interface{}{"key1": "val1", "key2": "val2"})
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Info, "testloggauge", map[string]interface{}{"key1": "val1", "key2": "val2", "type": "gauge", "value": 4.0}))
}
Beispiel #5
0
func TestLogCounter(t *testing.T) {
	buf := &bytes.Buffer{}
	logger := New("logger-tester")
	logger.SetOutput(buf)
	logger.Counter("testlogcounter")
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Info, "testlogcounter", map[string]interface{}{"type": "counter", "value": 1}))
	buf.Reset()
	logger.CounterD("testlogcounter", 2, map[string]interface{}{"key1": "val1", "key2": "val2"})
	assertLogFormatAndCompareContent(t, string(buf.Bytes()), kv.FormatLog(
		"logger-tester", kv.Info, "testlogcounter", map[string]interface{}{"key1": "val1", "key2": "val2", "type": "counter", "value": 2}))
}
Beispiel #6
0
// Fill make the necessary API calls to get all members of a Github Org. Then we attempt to find
// emails for every developer in their public history.
func (l UserList) Fill(u integrations.UserMap) (integrations.UserMap, error) {
	emailRgx = regexp.MustCompile(fmt.Sprintf(`"email":"(\w+\.\w+@%s)"`, l.Domain))

	ts := oauth2.StaticTokenSource(
		&oauth2.Token{AccessToken: l.Token},
	)
	tc := oauth2.NewClient(oauth2.NoContext, ts)
	gh := githubAPI.NewClient(tc)

	lo := githubAPI.ListMembersOptions{}
	for {
		members, resp, err := gh.Organizations.ListMembers(l.Org, &lo)
		if err != nil {
			return u, fmt.Errorf("Failed to form HTTP request for Github => {%s}", err)
		}
		for _, mbr := range members {
			if mbr.Login != nil && *mbr.Login != "" {
				email := findEmail(gh, *mbr.Login)
				if email == "" {
					continue
				}

				// add username to user if we find one with a matching email
				user, exists := u[email]
				if exists && user.Github == "" { // Don't override existing github usernames
					user.Github = *mbr.Login
					u[email] = user
				} else if exists {
					log.Println(kv.FormatLog("who-is-who", kv.Info, "github username exists", m{
						"existing-github": user.Github,
						"new-github":      *mbr.Login,
						"email":           email,
					}))
				} else {
					log.Println(kv.FormatLog("who-is-who", kv.Info, "mismatched email", m{
						"message": fmt.Sprintf("Found %s email but no user", l.Domain),
						"email":   email,
					}))
				}
			}
		}

		// cycle through all pages of org users
		if resp.NextPage == 0 {
			break
		} else {
			lo.Page = resp.NextPage
		}
	}

	return u, nil
}
Beispiel #7
0
// requiredEnv tries to find a value in the environment variables. If a value is not
// found the program will panaic.
func requiredEnv(key string) string {
	value := os.Getenv(key)
	if value == "" {
		log.Fatal(kayvee.FormatLog("who-is-who", kayvee.Error, "missing env var", m{
			"var": key,
		}))
	}
	return value
}
Beispiel #8
0
func TestMultipleLoggers(t *testing.T) {
	buf1 := &bytes.Buffer{}
	buf2 := &bytes.Buffer{}
	logger1 := New("logger-tester1")
	logger2 := New("logger-tester2")
	logger1.SetOutput(buf1)
	logger2.SetOutput(buf2)
	logger1.WarnD("testlogwarning", map[string]interface{}{"key1": "val1", "key2": "val2"})
	logger2.Info("testloginfo")
	logOutput1 := string(buf1.Bytes())
	assertLogFormatAndCompareContent(t, logOutput1, kv.FormatLog(
		"logger-tester1", kv.Warning, "testlogwarning", map[string]interface{}{"key1": "val1", "key2": "val2"}))
	assertLogFormatAndCompareContent(t, string(buf2.Bytes()), kv.FormatLog(
		"logger-tester2", kv.Info, "testloginfo", map[string]interface{}{}))

	logger2.SetOutput(buf1)
	logger2.Info("testloginfo")
	assert.NotEqual(t, logOutput1, string(buf1.Bytes()))
}
Beispiel #9
0
func main() {
	// get DB conn
	client, err := integrations.NewClient(dynamoTable, dynamoEndpoint, dynamoRegion, awsKey, awsSecret)
	if err != nil {
		log.Fatalf("Failed to connect => {%s}", err)
	}

	// get Slack info
	slackData := slack.NewUserMap(domain, slackToken)

	// seed a map of User's with emails
	emails, err := slackData.EmailList()
	if err != nil {
		log.Fatal(kayvee.FormatLog("who-is-who", kayvee.Error, "bad slack conn", m{
			"msg": err.Error(),
		}))
	}

	userMap := make(integrations.UserMap)
	for _, e := range emails {
		userMap[strings.ToLower(e)] = integrations.User{}
	}

	// declare all data sources to be used
	dataSources := []struct {
		Service integrations.InfoSource
		Name    string
	}{
		{slackData, "slack"},
		{aws.AwsService{}, "aws"},
		// Turning github integration off until bugs are fixed: INFRA-1124
		// {github.UserList{
		// 	Token:  githubToken,
		// 	Org:    githubOrg,
		// 	Domain: domain,
		// }, "github"},
	}

	// add data from every data source to every User object
	for _, src := range dataSources {
		var err error
		userMap, err = src.Service.Fill(userMap)
		if err != nil {
			log.Printf("Failed to get data from source, %s => {%s}", src.Name, err)
		}
	}

	// try to save everything
	err = client.SaveUsers(userMap)
	if err != nil {
		log.Fatalf("Failed to save users in Dynamo, %s", err)
	}

	log.Printf("Saved %d users", len(userMap))
}