Beispiel #1
0
func init() {
	var err error
	client, err = hipchat.NewClient(username, password, resource)
	if err != nil {
		log.Fatal(err.Error())
	}
}
Beispiel #2
0
func doHipChat(username, roomjid string) {
	if strings.HasSuffix(username, "@chat.hipchat.com") {
		username = strings.Replace(username, "@chat.hipchat.com", "", 1)
	}
	if !strings.HasSuffix(roomjid, "@conf.hipchat.com") {
		roomjid += "@conf.hipchat.com"
	}
	pass, err := getpass("Password for user \"" + username + "\": ")
	if err != nil {
		log.Print(err)
	}

	client, err := hipchat.NewClient(username, pass, "bot")
	if err != nil {
		log.Print(err)
		os.Exit(1)
	}

	nick, mname := getUserInfo(client, username)

	client.Status("chat")
	client.Join(roomjid, nick)
	log.Printf("[%s] now serving room [%s]", nick, roomjid)
	log.Print("hit ^C to exit")

	go client.KeepAlive()
	for message := range client.Messages() {
		if strings.HasPrefix(message.Body, "@"+mname) {
			go client.Say(roomjid, nick, process(message.Body))
		}
	}
}
Beispiel #3
0
func main() {
	user := "******"
	pass := "******"
	resource := "bot"

	client, err := hipchat.NewClient(user, pass, resource)
	if err != nil {
		fmt.Printf("client error: %s\n", err)
		return
	}

	var fullName string
	var mentionName string

	for _, user := range client.Users() {
		if user.Id == client.Id {
			fullName = user.Name
			mentionName = user.MentionName
			break
		}
	}

	fmt.Printf("name: %s\n", fullName)
	fmt.Printf("mention: %s\n", mentionName)
}
Beispiel #4
0
func main() {
	user := "******"
	pass := "******"
	resource := "bot"
	roomJid := "*****@*****.**"
	fullName := "Some Bot"
	mentionName := "SomeBot"

	client, err := hipchat.NewClient(user, pass, resource)
	if err != nil {
		fmt.Printf("client error: %s\n", err)
		return
	}

	client.Status("chat")
	client.Join(roomJid, fullName)

	go func() {
		for {
			select {
			case message := <-client.Messages():
				if strings.HasPrefix(message.Body, "@"+mentionName) {
					client.Say(roomJid, fullName, "Hello")
				}
			}
		}
	}()
	select {}
}
Beispiel #5
0
// Connect is the entry point for the robot. This will dial in the hipchat client with the provided credentials and
// start a keepAlive loop to prevent logouts.
// Upon connecting the bot will join all available rooms and gather all the user info from the server.
func (robot *Robot) Connect(jabberID string, password string) error {
	client, err := hipchat.NewClient(jabberID, password, "gobot")
	robot.client = client

	client.Status("chat")
	robot.JoinAllAvailableRooms()
	log.Printf("Connected to all available rooms")
	robot.initialLoaded = false

	robot.UserList = make(map[string]*hipchat.User)
	go robot.CollectUserObjects()

	go client.KeepAlive()
	return err
}
Beispiel #6
0
func NewBot(user, pass string) (*Bot, error) {

	c, err := hipchat.NewClient(user, pass, resource)
	if err != nil {
		return nil, err
	}

	c.Status("chat")

	log.Println("Connected and available")

	b := &Bot{
		client: c,
	}

	return b, b.init()
}
Beispiel #7
0
func main() {
	user := "******"
	pass := "******"
	resource := "bot"
	roomJid := "*****@*****.**"
	fullName := "Some Bot"

	client, err := hipchat.NewClient(user, pass, resource)
	if err != nil {
		fmt.Printf("client error: %s\n", err)
		return
	}

	client.Status("chat")
	client.Join(roomJid, fullName)
	client.Say(roomJid, fullName, "Hello")
	select {}
}
Beispiel #8
0
func newHipchatChatClient(L *lua.LState, co *CommonClientOption, opt *lua.LTable) {
	user, uok := getStringField(L, opt, "user")
	password, pok := getStringField(L, opt, "password")
	if !uok || !pok {
		L.RaiseError("'user' and 'password' are required")
	}
	host, _ := getStringField(L, opt, "host")
	if len(host) == 0 {
		host = "chat.hipchat.com"
	}
	conf, _ := getStringField(L, opt, "conf")
	if len(conf) == 0 {
		conf = "conf.hipchat.com"
	}
	resource, _ := getStringField(L, opt, "resource")
	if len(resource) == 0 {
		resource = "bot"
	}
	roomJids := L.GetField(opt, "room_jids")

	if co.Logger == nil {
		co.Logger = log.New(os.Stdout, "", log.Lshortfile|log.LstdFlags)
	}
	// hipchatobj, err := hipchat.NewClientWithServerInfo(user, password, resource, host, conf)
	hipchatobj, err := hipchat.NewClient(user, password, resource)
	if err != nil {
		co.Logger.Printf("[ERROR] %s", err.Error())
		os.Exit(1)
	}
	co.Logger.Printf("[INFO] connected to %s", host)
	chatClient := &hipchatChatClient{hipchatobj, co, co.Logger, make(map[string][]*lua.LFunction), []string{}, "", ""}
	if tbl, ok := roomJids.(*lua.LTable); ok {
		tbl.ForEach(func(key, value lua.LValue) {
			chatClient.roomsJids = append(chatClient.roomsJids, value.String())
		})
	}

	L.Push(newChatClient(L, hipchatChatClientTypeName, chatClient, luar.New(L, chatClient.hipchatobj).(*lua.LUserData)))
}
Beispiel #9
0
func main() {
	user := "******"
	pass := "******"
	resource := "bot"

	client, err := hipchat.NewClient(user, pass, resource)
	if err != nil {
		fmt.Printf("client error: %s\n", err)
		return
	}

	client.RequestUsers()

	select {
	case users := <-client.Users():
		for _, user := range users {
			if user.Id == client.Id {
				fmt.Printf("name: %s\n", user.Name)
				fmt.Printf("mention: %s\n", user.MentionName)
			}
		}
	}
}
Beispiel #10
0
func (a *adapter) startConnection() error {
	client, err := hipchat.NewClient(a.user, a.password, a.resource)
	if err != nil {
		hal.Logger.Error(err.Error())
		return err
	}

	client.Status("chat")

	for _, user := range client.Users() {
		// retrieve the name and mention name of our bot from the server
		if user.Id == client.Id {
			a.name = user.Name
			a.nick = user.MentionName
			// skip adding the bot to the users map
			continue
		}
		// Initialize a newUser object in case we need it.
		newUser := hal.User{
			ID:   user.Id,
			Name: user.Name,
			Options: map[string]interface{}{
				"mentionName": user.MentionName,
			},
		}
		// Prepopulate our users map because we can easily do so.
		// If a user doesn't exist, set it.
		u, err := a.Robot.Users.Get(user.Id)
		if err != nil {
			a.Robot.Users.Set(user.Id, newUser)
		}
		// If the user doesn't match completely (say, if someone changes their name),
		// then adjust what we have stored.
		if u.Name != user.Name || mentionName(&u) != user.MentionName {
			a.Robot.Users.Set(user.Id, newUser)
		}
	}

	// Make a map of room JIDs to human names
	roomJids := make(map[string]string, len(client.Rooms()))
	for _, room := range client.Rooms() {
		roomJids[room.Name] = room.Id
	}
	client.Status("chat")
	// Only join the rooms we want
	for _, room := range a.rooms {
		hal.Logger.Debugf("%s - joined %s", a, room)
		client.Join(roomJids[room], a.name)
	}

	a.client = client
	a.Robot.Alias = a.nick

	// send an empty string every 60 seconds so hipchat doesn't disconnect us
	go client.KeepAlive()

	for message := range client.Messages() {
		from := strings.Split(message.From, "/")
		// ignore messages directly from the channel
		// TODO: don't do this :)
		if len(from) < 2 {
			continue
		}
		// ingore messages from our bot
		if from[1] == a.name {
			continue
		}

		msg := a.newMessage(message)
		a.Receive(msg)
	}
	return nil
}
Beispiel #11
0
func main() {

	if len(os.Args) != 3 {
		fmt.Printf(
			`rtop-bot %s - (c) 2015 RapidLoop - http://www.rtop-monitor.org/rtop-bot
rtop-bot is a HipChat bot that can do remote system monitoring over SSH

Usage: rtop-bot userJid roomJid

where
  userJid is the HipChat user jabber ID, like 139999_999914
  roomJid is the HipChat room jabber ID, like 139999_opschat
`, VERSION)
		os.Exit(1)
	}

	log.SetPrefix("rtop-bot: ")
	log.SetFlags(0)

	username := os.Args[1]
	roomjid := os.Args[2]
	if strings.HasSuffix(username, "@chat.hipchat.com") {
		username = strings.Replace(username, "@chat.hipchat.com", "", 1)
	}
	if !strings.HasSuffix(roomjid, "@conf.hipchat.com") {
		roomjid += "@conf.hipchat.com"
	}
	pass, err := getpass("Password for user \"" + username + "\": ")
	if err != nil {
		log.Print(err)
	}

	// get default username for SSH connections
	usr, err := user.Current()
	if err != nil {
		log.Print(err)
		os.Exit(1)
	}
	sshUsername = usr.Username

	// expand ~/.ssh/id_rsa and check if it exists
	idRsaPath = filepath.Join(usr.HomeDir, ".ssh", "id_rsa")
	if _, err := os.Stat(idRsaPath); os.IsNotExist(err) {
		idRsaPath = ""
	}

	// expand ~/.ssh/config and parse if it exists
	sshConfig := filepath.Join(usr.HomeDir, ".ssh", "config")
	if _, err := os.Stat(sshConfig); err == nil {
		parseSshConfig(sshConfig)
	}

	client, err := hipchat.NewClient(username, pass, "bot")
	if err != nil {
		log.Print(err)
		os.Exit(1)
	}

	nick, mname := getUserInfo(client, username)

	client.Status("chat")
	client.Join(roomjid, nick)
	log.Printf("[%s] now serving room [%s]", nick, roomjid)
	log.Print("hit ^C to exit")

	go client.KeepAlive()
	for message := range client.Messages() {
		if strings.HasPrefix(message.Body, "@"+mname) {
			go client.Say(roomjid, nick, process(message.Body))
		}
	}
}