feed-to-muc/feed-to-muc.go

/* Copyright 2018 Martin Dosch
Licensed under the "MIT License" */

package main

import (
	"encoding/json"
	"flag"
	"log"
	"os"
	"os/user"
	"strings"
	"time"

	"github.com/mattn/go-xmpp"
)

func main() {

	var err error
	var configPath, configFile string

	type configuration struct {
		ServerAddress string
		BotJid        string
		Password      string
		Muc           string
		MucNick       string
		MaxArticles   int
		Feeds         []string
	}

	// Read path to config from command line option.
	configFilePtr := flag.String("config", "none", "path to configuration file")
	flag.Parse()

	if *configFilePtr != "none" {
		configFile = *configFilePtr
	} else {
		// Get systems user config path.
		osConfigDir := os.Getenv("$XDG_CONFIG_HOME")
		if osConfigDir != "" {
			// Create configPath if not yet existing.
			configPath = osConfigDir + "/.config/feed-to-muc/"
			if _, err := os.Stat(configPath); os.IsNotExist(err) {
				err = os.MkdirAll(configPath, 0700)
				if err != nil {
					log.Fatal("Error: ", err)
				}
			}

		} else { // Get the current user.
			curUser, err := user.Current()
			if err != nil {
				log.Fatal("Error: ", err)
				return
			}
			// Get home directory.
			home := curUser.HomeDir

			if home == "" {
				log.Fatal("Error: No home directory available.")
				return
			}

			// Create configPath if not yet existing.
			configPath = home + "/.config/feed-to-muc/"
			if _, err := os.Stat(configPath + "config.json"); os.IsNotExist(err) {
				err = os.MkdirAll(configPath, 0700)
				if err != nil {
					log.Fatal("Error: ", err)
				}
			}

		}
		configFile = configPath + "config.json"
	}

	// Check that config file is existing.
	if _, err := os.Stat(configFile); os.IsNotExist(err) {
		log.Fatal("Error: ", err)
	}

	// Read configuration file into variable config.
	file, _ := os.Open(configFile)
	defer file.Close()
	decoder := json.NewDecoder(file)
	config := configuration{}
	if err := decoder.Decode(&config); err != nil {
		log.Fatal("Error: ", err)
	}

	if _, err := os.Stat(configFile); os.IsNotExist(err) {
		err = os.MkdirAll(configPath, 0700)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}

	var client *xmpp.Client

	options := xmpp.Options{
		Host:     config.ServerAddress,
		User:     config.BotJid,
		Password: config.Password,
		NoTLS:    true,
		StartTLS: true,
		Debug:    false,
	}

	client, err = options.NewClient()
	if err != nil {
		log.Fatal(err)
	}

	// Starting goroutine to ping the server every 30 seconds.
	go ping(client, config.ServerAddress, config.BotJid)

	// Join the MUC
	mucStatus, err := client.JoinMUCNoHistory(config.Muc, config.MucNick)
	if err != nil {
		log.Fatal(err)
	}

	// Exit if Status is > 300, see https://xmpp.org/registrar/mucstatus.html
	if mucStatus > 300 {
		os.Exit(mucStatus)
	}

	for {
		_, err := client.Recv()
		if err != nil {
			log.Fatal(err)
		}

		for i := 0; i < len(config.Feeds); i++ {
			output, err := getArticles(config.Feeds[i], config.MaxArticles)
			if err != nil {
				log.Fatal(err)
			}

			if output != "" {
				_, err = client.Send(xmpp.Chat{Remote: config.Muc, Type: "groupchat", Text: output})
				if err != nil {
					// ToDo: Save message for resend.
					log.Fatal(err)
				}
			}
		}
		time.Sleep(30 * time.Second)
	}
}

// Send a ping every 30 seconds to check if the server is still available.
func ping(client *xmpp.Client, server string, botJid string) {
	for {
		time.Sleep(30 * time.Second)
		err := client.PingC2S(botJid, strings.Split(server, ":")[0])
		if err != nil {
			log.Fatal(err)
		}
	}
}