Error handling. Vendoring

Signed-off-by: Ettore Dreucci <ettore.dreucci@gmail.com>

src/barandaBot.go

@@ -0,0 +1,34 @@
+package main
+
+import "log"
+
+func main() {
+
+	cmdFlags, err := getFlags()
+	if err != nil {
+		log.Fatalln("Error in parsing command line flags. Abort!")
+	}
+
+	redisClient, err := redisInit(cmdFlags.redisAddr, cmdFlags.redisPwd, cmdFlags.redisDB)
+	defer redisClient.Close()
+	if err != nil {
+		log.Fatalf("Error in initializing redis instance: %v", err)
+	}
+
+	startMenu()
+
+	bots, err := botInit(redisClient)
+	if err != nil {
+		log.Fatalf("Error in initializing bots: %v", err)
+	}
+
+	for _, bot := range bots {
+		defer bot.Stop()
+	}
+
+	/*b.Handle("/hello", func(m *tb.Message) {
+		b.Send(m.Sender, "hello world")
+	})
+
+	b.Start()*/
+}

src/redisAPI.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/go-redis/redis"
+)
+
+const (
+	tkSet = "botTokens"
+)
+
+var (
+	//ErrRedisConnection is thrown when a redis connection error occurs
+	ErrRedisConnection = errors.New("redis: couldn't connect to remote instance")
+	//ErrRedisAddSet is thrown when it's not possible to add a key in a set
+	ErrRedisAddSet = errors.New("redis: couldn't add key in set")
+	//ErrRedisRetriveSet is thrown when it's not possible to retrive keys from a set
+	ErrRedisRetriveSet = errors.New("redis: couldn't retrive keys from set")
+	//ErrTokenParsing is thrown when it's not possible to parse the bot token
+	ErrTokenParsing = errors.New("botToken: cannot parse token")
+	//ErrTokenInvalid is thrown when the string parsed isn't a valid telegram bot token
+	ErrTokenInvalid = errors.New("botToken: string isn't a valid telegram bot token")
+	//ErrAddToken is thrown when one or more bot token hasn't been added
+	ErrAddToken = errors.New("couldn't add one or more token")
+)
+
+func redisInit(addr string, pwd string, db int) (*redis.Client, error) {
+	redisClient := redis.NewClient(&redis.Options{
+		Addr:     addr,
+		Password: pwd,
+		DB:       db,
+	})
+	err := redisClient.Ping().Err()
+	if err != nil {
+		log.Printf("Error in connecting to redis instance: %v", err)
+		return nil, ErrRedisConnection
+	}
+	return redisClient, nil
+}
+
+func addBotToken(newToken string, client *redis.Client) error {
+	token := strings.TrimSpace(newToken)
+	matched, err := regexp.MatchString("^\\d+\\:([0-9]|[A-z]|\\_|\\-)+", token)
+	if err != nil {
+		log.Printf("Error in parsing bot token: %v", err)
+		return ErrTokenParsing
+	}
+	if !matched {
+		return ErrTokenInvalid
+	}
+
+	err = client.SAdd(tkSet, token).Err()
+	if err != nil {
+		log.Printf("Error in adding new bot token: %v", err)
+		return ErrRedisAddSet
+	}
+	return nil
+}
+
+func addBotTokens(client *redis.Client) error {
+	fmt.Println("Add the new tokens, comma-separated:")
+	reader := bufio.NewReader(os.Stdin)
+	line, err := reader.ReadString('\n')
+	if err != nil {
+		log.Printf("Error in reading new bot tokens: %v", err)
+		return ErrStdRead
+	}
+	newTokens := strings.Split(line, ",")
+	for _, newToken := range newTokens {
+		err = addBotToken(newToken, client)
+		if err != nil {
+			log.Printf("Error in adding new bot token %s: %v", newToken, err)
+		}
+	}
+	return nil
+}
+
+func getBotTokens(client *redis.Client) ([]string, error) {
+	tkNum, err := client.SCard(tkSet).Result()
+	if err != nil {
+		log.Printf("Couldn't retrive number of bot tokens: %v", err)
+		return nil, ErrRedisRetriveSet
+	}
+	if tkNum == 0 {
+		fmt.Println("No bot token found.")
+		err := addBotTokens(client)
+		if err != nil {
+			log.Printf("Couldn't add new bot tokens: %v", err)
+			return nil, ErrAddToken
+		}
+	}
+
+	tokens, err := client.SMembers(tkSet).Result()
+	if err != nil {
+		log.Printf("Couldn't retrive bot tokens: %v", err)
+		return nil, ErrRedisRetriveSet
+	}
+
+	return tokens, nil
+}

src/sys.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+
+	"github.com/dixonwille/wmenu"
+)
+
+type flags struct {
+	redisAddr string
+	redisPwd  string
+	redisDB   int
+}
+
+var (
+	//ErrStdRead it thrown when it's not possible to read from the standard input
+	ErrStdRead = errors.New("couldn't read string from stdin")
+)
+
+func getFlags() (flags, error) {
+
+	var cmdFlags flags
+
+	const (
+		defaultAddr = "127.0.0.1:6379"
+		addrUsage   = "The address of the redis instance"
+		defaultPwd  = ""
+		pwdUsage    = "The password of the redis instance"
+		defaultDB   = 0
+		dbUsage     = "The database to be selected after connecting to redis instance"
+	)
+
+	flag.StringVar(&(cmdFlags.redisAddr), "redisAddr", defaultAddr, addrUsage)
+	flag.StringVar(&(cmdFlags.redisAddr), "a", defaultAddr, addrUsage+"(shorthand)")
+	flag.StringVar(&(cmdFlags.redisPwd), "redisPwd", defaultPwd, pwdUsage)
+	flag.StringVar(&(cmdFlags.redisPwd), "p", defaultPwd, pwdUsage+"(shorthand)")
+	flag.IntVar(&(cmdFlags.redisDB), "redisDB", defaultDB, dbUsage)
+	flag.IntVar(&(cmdFlags.redisDB), "d", defaultDB, dbUsage+"(shorthand)")
+
+	flag.Parse()
+
+	return cmdFlags, nil
+}
+
+func startMenu() {
+	fmt.Println("Welcome in barandaBot! Here you can control the bot(s) options and configurations.")
+	menu := wmenu.NewMenu("What do you want to do?")
+	menu.Action(func)
+}

src/telegramAPI.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"log"
+	"time"
+
+	"github.com/go-redis/redis"
+	tb "gopkg.in/tucnak/telebot.v2"
+)
+
+func botInit(redisClient *redis.Client) ([]*tb.Bot, error) {
+	var bots []*tb.Bot
+
+	tokens, err := getBotTokens(redisClient)
+	if err != nil {
+		log.Printf("Error in retriving bot tokens: %v. Cannot start telebot without tokens.", err)
+		return nil, err
+	}
+
+	for _, token := range tokens {
+		bot, err := tb.NewBot(tb.Settings{
+			Token:  token,
+			Poller: &tb.LongPoller{Timeout: 10 * time.Second},
+		})
+
+		if err != nil {
+			log.Printf("Error in enstablishing connection for bot %s: %v", bot.Me.Username, err)
+		} else {
+			bots = append(bots, bot)
+		}
+	}
+	return bots, nil
+}