ergo/irc/config.go

package irc

import (
	"crypto/tls"
	"errors"
	"io/ioutil"
	"log"

	"gopkg.in/yaml.v2"
)

type PassConfig struct {
	Password string
}

// SSLListenConfig defines configuration options for listening on SSL
type SSLListenConfig struct {
	Cert string
	Key  string
}

// Certificate returns the SSL certificate assicated with this SSLListenConfig
func (conf *SSLListenConfig) Config() (*tls.Config, error) {
	cert, err := tls.LoadX509KeyPair(conf.Cert, conf.Key)
	if err != nil {
		return nil, errors.New("ssl cert+key: invalid pair")
	}

	return &tls.Config{
		Certificates: []tls.Certificate{cert},
	}, err
}

func (conf *PassConfig) PasswordBytes() []byte {
	bytes, err := DecodePassword(conf.Password)
	if err != nil {
		log.Fatal("decode password error: ", err)
	}
	return bytes
}

type Config struct {
	Network struct {
		Name string
	}

	Server struct {
		PassConfig
		Name     string
		Database string
		Listen   []string
		Wslisten string
		Log      string
		MOTD     string
	}

	SSLListener map[string]*SSLListenConfig

	Operator map[string]*PassConfig

	Theater map[string]*PassConfig
}

func (conf *Config) Operators() map[Name][]byte {
	operators := make(map[Name][]byte)
	for name, opConf := range conf.Operator {
		operators[NewName(name)] = opConf.PasswordBytes()
	}
	return operators
}

func (conf *Config) Theaters() map[Name][]byte {
	theaters := make(map[Name][]byte)
	for s, theaterConf := range conf.Theater {
		name := NewName(s)
		if !name.IsChannel() {
			log.Fatal("config uses a non-channel for a theater!")
		}
		theaters[name] = theaterConf.PasswordBytes()
	}
	return theaters
}

func (conf *Config) SSLListeners() map[Name]*tls.Config {
	sslListeners := make(map[Name]*tls.Config)
	for s, sslListenersConf := range conf.SSLListener {
		config, err := sslListenersConf.Config()
		if err != nil {
			log.Fatal(err)
		}
		sslListeners[NewName(s)] = config
	}
	return sslListeners
}

func LoadConfig(filename string) (config *Config, err error) {
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

	err = yaml.Unmarshal(data, &config)
	if err != nil {
		return nil, err
	}

	if config.Network.Name == "" {
		return nil, errors.New("Network name missing")
	}
	if config.Server.Name == "" {
		return nil, errors.New("Server name missing")
	}
	if config.Server.Database == "" {
		return nil, errors.New("Server database missing")
	}
	if len(config.Server.Listen) == 0 {
		return nil, errors.New("Server listening addresses missing")
	}
	return config, nil
}