153 lines
2.9 KiB
Go
153 lines
2.9 KiB
Go
package gavalink
|
|
|
|
import (
|
|
"errors"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Log sets the log.Logger gavalink will write to
|
|
var Log *log.Logger
|
|
|
|
func init() {
|
|
Log = log.New(os.Stdout, "(gavalink) ", 0)
|
|
}
|
|
|
|
// Lavalink manages a connection to Lavalink Nodes
|
|
type Lavalink struct {
|
|
shards string
|
|
userID string
|
|
|
|
nodes []*Node
|
|
players map[string]*Player
|
|
|
|
// Event handlers
|
|
handlersMu sync.RWMutex
|
|
handlers map[string][]*eventHandlerInstance
|
|
onceHandlers map[string][]*eventHandlerInstance
|
|
|
|
capabilities map[string]interface{}
|
|
|
|
BestNodeFunc func([]*Node) (*Node, error)
|
|
}
|
|
|
|
var (
|
|
errNoNodes = errors.New("No nodes present")
|
|
errNodeNotFound = errors.New("Couldn't find that node")
|
|
errPlayerNotFound = errors.New("Couldn't find a player for that guild")
|
|
errVolumeOutOfRange = errors.New("Volume is out of range, must be within [0, 1000]")
|
|
errInvalidVersion = errors.New("This library requires Lavalink >= 3")
|
|
errUnknownPayload = errors.New("Lavalink sent an unknown payload")
|
|
errNilHandler = errors.New("You must provide an event handler. Use gavalink.DummyEventHandler if you wish to ignore events")
|
|
)
|
|
|
|
// NewLavalink creates a new Lavalink manager
|
|
func NewLavalink(shards string, userID string) *Lavalink {
|
|
return &Lavalink{
|
|
shards: shards,
|
|
userID: userID,
|
|
players: make(map[string]*Player),
|
|
|
|
BestNodeFunc: BestNodeByPenalties,
|
|
}
|
|
}
|
|
|
|
// AddNodes adds a node to the Lavalink manager
|
|
func (l *Lavalink) AddNodes(nodeConfigs ...NodeConfig) error {
|
|
nodes := make([]*Node, len(nodeConfigs))
|
|
|
|
client := &http.Client{
|
|
Timeout: 60 * time.Second,
|
|
}
|
|
|
|
for i, c := range nodeConfigs {
|
|
n := &Node{
|
|
config: c,
|
|
manager: l,
|
|
client: client,
|
|
}
|
|
|
|
err := n.open()
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
nodes[i] = n
|
|
}
|
|
|
|
l.nodes = append(l.nodes, nodes...)
|
|
|
|
return nil
|
|
}
|
|
|
|
// RemoveNode removes a node from the manager
|
|
func (l *Lavalink) removeNode(node *Node) error {
|
|
idx := -1
|
|
for i, n := range l.nodes {
|
|
if n == node {
|
|
idx = i
|
|
break
|
|
}
|
|
}
|
|
if idx == -1 {
|
|
return errNodeNotFound
|
|
}
|
|
|
|
node.stop()
|
|
|
|
for _, player := range l.players {
|
|
if player.node == node {
|
|
n, err := l.BestNode()
|
|
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
player.ChangeNode(n)
|
|
}
|
|
}
|
|
|
|
// temp var for easier reading
|
|
n := l.nodes
|
|
z := len(n) - 1
|
|
|
|
n[idx] = n[z] // swap idx with last
|
|
n = n[:z]
|
|
|
|
l.nodes = n
|
|
return nil
|
|
}
|
|
|
|
// BestNode returns the Node with the lowest latency
|
|
func (l *Lavalink) BestNode() (*Node, error) {
|
|
if len(l.nodes) < 1 {
|
|
return nil, errNoNodes
|
|
}
|
|
|
|
return l.BestNodeFunc(l.nodes)
|
|
}
|
|
|
|
// GetPlayer gets a player for a guild
|
|
func (l *Lavalink) GetPlayer(guild string) (*Player, error) {
|
|
p, ok := l.players[guild]
|
|
|
|
if !ok {
|
|
return nil, errPlayerNotFound
|
|
}
|
|
|
|
return p, nil
|
|
}
|
|
|
|
// Add capabilities mappings to the client, letting the server know what we support
|
|
func (l *Lavalink) AddCapability(key string, i interface{}) {
|
|
if l.capabilities == nil {
|
|
l.capabilities = make(map[string]interface{})
|
|
}
|
|
|
|
l.capabilities[key] = i
|
|
}
|