bot/irc/profile.go

// This file is subject to a 1-clause BSD license.
// Its contents can be found in the enclosed LICENSE file.

// Package irc defines some utility types and functions for an IRC bot.
package irc

import (
	"strings"
	"sync"

	"notabug.org/mouz/bot/app/util"
)

// Profile defines bot configuration data.
type Profile interface {
	// Root defines the root directory with the bot's configuration data.
	Root() string

	// Channels yields all channels the bot should join on startup.
	Channels() []Channel

	// Address defines the host and port of the server/network to connect to.
	Address() string

	// Nickname yields the bot's nickname.
	Nickname() string

	// SetNickname sets the bot's nickname. This is generally only called
	// when the bot logs in and finds its name alredy in use. If the nick
	// can not be regained, this function is used to alter it to something
	// which is still available.
	SetNickname(string)

	// NickservPassword defines the bot's nickserv password. This will be
	// used to register the bot when it logs in. It is only relevant if the
	// bot has a registered nickname and nickserv exists on the server.
	NickservPassword() string

	// SetNickservPassword sets the bot's nickserv password. This is be
	// used to register the bot when it logs in. It is only relevant if the
	// bot has a registered nickname and nickserv exists on the server.
	SetNickservPassword(string)

	// CommandPrefix this is the prefix used for all bot commands. Whenever
	// the bot reads incoming PRIVMSG data, it looks for this prefix to
	// determine if a command call was issued or not.
	CommandPrefix() string

	// Save saves the profile to disk.
	Save() error

	// Load loads the profile from disk.
	Load() error

	// IsWhitelisted returns true if the given hostmask is in the whitelist.
	// This means the user to whom it belongs is allowed to execute restricted
	// commands. This performs a case-insensitive comparison.
	IsWhitelisted(string) bool

	// Whitelist returns a copy of the current whitelist.
	Whitelist() []string

	// WhitelistAdd adds the given hostmask to the whitelist,
	// provided it does not already exist.
	WhitelistAdd(string)

	// WhitelistRemove removes the given hostmask from the whitelist,
	// provided it exists.
	WhitelistRemove(string)

	// IsMe returns true if the given name equals the bot's nickname.
	// This is used in request handlers to quickly check if a request
	// is targeted specifically at this bot or not.
	IsMe(string) bool

	// ForkArgs returns a list of command line arguments which should be
	// passed to a forked child process.
	ForkArgs() []string
}

// profile defines bot configuration data.
//
// The fields are embedded in a sub struct to differentiate them from the
// method names needed to qualify as a Profile interface. I would rather
// just make these field names lower case, but Go's JSON decoder will not
// work on non-exported fields. Thus breaking the Load/Save functionality.
type profile struct {
	m    sync.RWMutex
	root string
	data profileData
}

// profileData defines the parts of the profile which are saved to
// an external configuration file.
type profileData struct {
	Whitelist        []string
	Channels         []Channel
	Address          string
	Nickname         string
	NickservPassword string
	CommandPrefix    string
}

// NewProfile creates a new profile for the given root directory.
func NewProfile(root string) Profile {
	return &profile{
		root: root,
		data: profileData{
			Address:  "server.net:6667",
			Nickname: "bot_name",
			Channels: []Channel{
				{Name: "#test_channel"},
			},
			Whitelist: []string{
				"~user@server.com",
			},
			CommandPrefix: "!",
		},
	}
}

func (p *profile) Root() string {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.root
}

func (p *profile) ForkArgs() []string {
	p.m.RLock()
	defer p.m.RUnlock()
	return []string{p.root}
}

func (p *profile) Channels() []Channel {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.data.Channels
}

func (p *profile) Address() string {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.data.Address
}

func (p *profile) Nickname() string {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.data.Nickname
}

func (p *profile) SetNickname(v string) {
	p.m.Lock()
	p.data.Nickname = v
	p.m.Unlock()
	p.Save()
}

func (p *profile) NickservPassword() string {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.data.NickservPassword
}

func (p *profile) SetNickservPassword(v string) {
	p.m.Lock()
	p.data.NickservPassword = v
	p.m.Unlock()
	p.Save()
}

func (p *profile) CommandPrefix() string {
	p.m.RLock()
	defer p.m.RUnlock()
	return p.data.CommandPrefix
}

func (p *profile) Whitelist() []string {
	p.m.RLock()
	defer p.m.RUnlock()

	out := make([]string, len(p.data.Whitelist))
	copy(out, p.data.Whitelist)
	return out
}

func (p *profile) WhitelistAdd(mask string) {
	p.m.Lock()

	for _, str := range p.data.Whitelist {
		if strings.EqualFold(str, mask) {
			p.m.Unlock()
			return
		}
	}

	p.data.Whitelist = append(p.data.Whitelist, mask)
	p.m.Unlock()
	p.Save()
}

func (p *profile) WhitelistRemove(mask string) {
	p.m.Lock()

	for i, str := range p.data.Whitelist {
		if !strings.EqualFold(str, mask) {
			continue
		}

		copy(p.data.Whitelist[i:], p.data.Whitelist[i+1:])
		p.data.Whitelist = p.data.Whitelist[:len(p.data.Whitelist)-1]
		break
	}

	p.m.Unlock()
	p.Save()
}

func (p *profile) IsWhitelisted(mask string) bool {
	p.m.RLock()
	defer p.m.RUnlock()

	for _, str := range p.data.Whitelist {
		if strings.EqualFold(str, mask) {
			return true
		}
	}

	return false
}

func (p *profile) IsMe(name string) bool {
	p.m.RLock()
	defer p.m.RUnlock()
	return strings.EqualFold(p.data.Nickname, name)
}

func (p *profile) Save() error {
	p.m.RLock()
	err := util.WriteFile("profile.cfg", p.data, false)
	p.m.RUnlock()
	return err
}

func (p *profile) Load() error {
	p.m.Lock()
	err := util.ReadFile("profile.cfg", &p.data, false)
	p.m.Unlock()
	return err
}