/
slack.go
131 lines (115 loc) · 3.2 KB
/
slack.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package slack
import (
"fmt"
"log"
"os"
"strings"
"github.com/nlopes/slack"
"github.com/danielqsj/k8s-slackbot/pkg/kubernetes"
)
// SlackBot defines a slack client
type SlackBot struct {
Client *slack.Client
}
// InitSlackLog inits slack log
func InitSlackLog() {
logger := log.New(os.Stdout, "slack-bot: ", log.Lshortfile|log.LstdFlags)
slack.SetLogger(logger)
}
// NewSlackBot returns new slackbot with token
func NewSlackBot(token string) SlackBot {
return SlackBot{
Client: slack.New(token),
}
}
// EnableDebug enables debug log
func (bot SlackBot) EnableDebug() {
bot.Client.SetDebug(true)
}
// RunSlackRTMServer runs rtm server
func (bot SlackBot) RunSlackRTMServer(kubeconfig string) {
rtm := bot.Client.NewRTM()
go rtm.ManageConnection()
for msg := range rtm.IncomingEvents {
switch ev := msg.Data.(type) {
case *slack.MessageEvent:
input := strings.Split(strings.TrimSpace(ev.Msg.Text), " ")
if len(input) > 0 {
command := input[0]
args := input[1:]
log.Printf("command: %v, args: %v", command, args)
switch command {
case "kubectl":
if len(args) > 0 {
output, err := kubernetes.RunKubectl(kubeconfig, args)
if err != nil {
rtm.SendMessage(rtm.NewOutgoingMessage(err.Error(), ev.Msg.Channel))
} else {
rtm.SendMessage(rtm.NewOutgoingMessage(output, ev.Msg.Channel))
}
}
}
}
case *slack.InvalidAuthEvent:
log.Printf("Invalid credentials")
return
case *slack.RTMError:
log.Printf("Error: %s\n", ev.Error())
default:
}
}
}
// GetUserName returns username by userid
func (bot SlackBot) GetUserName(userId string) string {
user, err := bot.Client.GetUserInfo(userId)
if err != nil {
bot.Client.Debugf("GetUserName err: %s\n", err)
return ""
}
return user.Profile.FirstName + " " + user.Profile.LastName
}
// GetUserId returns userid by username
func (bot SlackBot) GetUserId(userName string) (string, error) {
users, err := bot.Client.GetUsers()
if err != nil {
return "", err
}
for _, user := range users {
if user.Name == userName {
return user.ID, nil
}
}
return "", fmt.Errorf("Cannot find this user %s", userName)
}
// SendMessage sends message to users
func (bot SlackBot) SendMessage(userNames []string, message string) {
params := slack.PostMessageParameters{}
for _, userName := range userNames {
userId, err := bot.GetUserId(userName)
if err != nil {
log.Printf("GetUserId err: %s\n", err)
return
}
channelID, timestamp, err := bot.Client.PostMessage(userId, message, params)
if err != nil {
log.Printf("Send slack message err: %s\n", err)
return
}
log.Printf("Send slack message successfully to channel %s at %s", channelID, timestamp)
}
}
// SendMessages sends messages to a user
func (bot SlackBot) SendMessages(userName string, message []string) {
params := slack.PostMessageParameters{}
userId, err := bot.GetUserId(userName)
if err != nil {
log.Printf("GetUserId err: %s\n", err)
return
}
channelID, timestamp, err := bot.Client.PostMessage(userId, strings.Join(message, "\n"), params)
if err != nil {
log.Printf("Send slack message err: %s\n", err)
return
}
log.Printf("Send slack message successfully to channel %s at %s", channelID, timestamp)
}