yammerbot/bridge.go

301 lines
7.1 KiB
Go
Raw Normal View History

package main
import (
2021-02-01 16:03:38 -05:00
"context"
"crypto/tls"
"fmt"
"log"
"net"
2021-03-05 14:12:34 -05:00
"os"
"strconv"
"sync"
"time"
"github.com/bwmarrin/discordgo"
"layeh.com/gumble/gumble"
)
type discordUser struct {
username string
seen bool
dm *discordgo.Channel
}
2021-01-08 14:38:21 -05:00
//BridgeState manages dynamic information about the bridge during runtime
type BridgeState struct {
// The configuration data for this bridge
BridgeConfig *BridgeConfig
2021-02-01 16:03:38 -05:00
// External requests to kill the bridge
BridgeDie chan bool
2021-02-01 16:03:38 -05:00
// Lock to only allow one bridge session at a time
lock sync.Mutex
// Wait for bridge to exit cleanly
WaitExit *sync.WaitGroup
// Bridge State Mutex
BridgeMutex sync.Mutex
// Bridge connection
Connected bool
// The bridge mode constant, auto, manual. Default is constant.
Mode bridgeMode
// Discord session. This is created and outside the bridge state
DiscordSession *discordgo.Session
// Discord voice connection. Empty if not connected.
DiscordVoice *discordgo.VoiceConnection
// Mumble client. Empty if not connected.
MumbleClient *gumble.Client
// Map of Discord users tracked by this bridge.
DiscordUsers map[string]discordUser
DiscordUsersMutex sync.Mutex
// Map of Mumble users tracked by this bridge
MumbleUsers map[string]bool
MumbleUsersMutex sync.Mutex
// Total Number of Mumble users
MumbleUserCount int
// Kill the auto connect routine
AutoChanDie chan bool
// Discord Duplex and Event Listener
DiscordStream *DiscordDuplex
DiscordListener *DiscordListener
// Mumble Duplex and Event Listener
MumbleStream *MumbleDuplex
MumbleListener *MumbleListener
// Discord Voice channel to join
DiscordChannelID string
}
// startBridge established the voice connection
func (b *BridgeState) startBridge() {
2021-02-01 16:03:38 -05:00
b.lock.Lock()
defer b.lock.Unlock()
b.BridgeDie = make(chan bool)
2021-02-01 16:03:38 -05:00
defer close(b.BridgeDie)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
wg := sync.WaitGroup{}
b.WaitExit = &wg
var err error
// DISCORD Connect Voice
2021-02-01 16:03:38 -05:00
log.Println("Attempting to join Discord voice channel")
if b.DiscordChannelID == "" {
log.Println("Tried to start bridge but no Discord channel specified")
return
}
b.DiscordVoice, err = b.DiscordSession.ChannelVoiceJoin(b.BridgeConfig.GID, b.DiscordChannelID, false, false)
if err != nil {
log.Println(err)
2021-02-01 16:03:38 -05:00
b.DiscordVoice.Disconnect()
return
}
2021-02-01 16:03:38 -05:00
defer b.DiscordVoice.Disconnect()
defer b.DiscordVoice.Speaking(false)
2021-02-01 16:03:38 -05:00
log.Println("Discord Voice Connected")
// MUMBLE Connect
2021-02-01 16:03:38 -05:00
b.MumbleStream = &MumbleDuplex{}
det := b.BridgeConfig.MumbleConfig.AudioListeners.Attach(b.MumbleStream)
2021-02-01 16:03:38 -05:00
defer det.Detach()
var tlsConfig tls.Config
if b.BridgeConfig.MumbleInsecure {
tlsConfig.InsecureSkipVerify = true
}
if b.BridgeConfig.MumbleCertificate != "" {
2021-03-05 14:15:17 -05:00
keyFile := b.BridgeConfig.MumbleCertificate
if certificate, err := tls.LoadX509KeyPair(keyFile, keyFile); err != nil {
fmt.Fprintf(os.Stderr, "%s: %s\n", os.Args[0], err)
os.Exit(1)
} else {
tlsConfig.Certificates = append(tlsConfig.Certificates, certificate)
}
}
2021-02-01 16:03:38 -05:00
log.Println("Attempting to join Mumble")
b.MumbleClient, err = gumble.DialWithDialer(new(net.Dialer), b.BridgeConfig.MumbleAddr, b.BridgeConfig.MumbleConfig, &tlsConfig)
if err != nil {
log.Println(err)
b.DiscordVoice.Disconnect()
return
}
defer b.MumbleClient.Disconnect()
2021-02-01 16:03:38 -05:00
log.Println("Mumble Connected")
// Shared Channels
// Shared channels pass PCM information in 10ms chunks [480]int16
// These channels are internal and are not added to the bridge state.
var toMumble = b.MumbleClient.AudioOutgoing()
var toDiscord = make(chan []int16, 100)
2021-02-01 16:03:38 -05:00
defer close(toDiscord)
defer close(toMumble)
// Start Passing Between
// From Mumble
2021-02-01 16:03:38 -05:00
go b.MumbleStream.fromMumbleMixer(ctx, &wg, toDiscord)
// From Discord
b.DiscordStream = &DiscordDuplex{
Bridge: b,
fromDiscordMap: make(map[uint32]fromDiscord),
}
2021-02-01 16:03:38 -05:00
go b.DiscordStream.discordReceivePCM(ctx, &wg, cancel)
go b.DiscordStream.fromDiscordMixer(ctx, &wg, toMumble)
// To Discord
2021-02-01 16:03:38 -05:00
go b.DiscordStream.discordSendPCM(ctx, &wg, cancel, toDiscord)
2021-02-01 16:03:38 -05:00
// Monitor Mumble
2021-04-06 22:34:38 -04:00
wg.Add(1)
go func() {
ticker := time.NewTicker(500 * time.Millisecond)
for {
2021-02-01 16:03:38 -05:00
select {
case <-ticker.C:
if b.MumbleClient == nil || b.MumbleClient.State() != 2 {
if b.MumbleClient != nil {
log.Println("Lost mumble connection " + strconv.Itoa(int(b.MumbleClient.State())))
} else {
log.Println("Lost mumble connection due to bridge dieing")
}
cancel()
}
2021-02-01 16:03:38 -05:00
case <-ctx.Done():
wg.Done()
return
}
}
}()
b.BridgeMutex.Lock()
b.Connected = true
b.BridgeMutex.Unlock()
2021-01-03 20:48:34 -05:00
2021-02-01 16:03:38 -05:00
// Hold until cancelled or external die request
select {
2021-02-01 16:03:38 -05:00
case <-ctx.Done():
log.Println("Bridge internal context cancel")
case <-b.BridgeDie:
2021-02-01 16:03:38 -05:00
log.Println("Bridge die request received")
cancel()
}
2021-02-01 16:03:38 -05:00
b.BridgeMutex.Lock()
2021-02-01 16:03:38 -05:00
b.Connected = false
b.BridgeMutex.Unlock()
2021-02-01 16:03:38 -05:00
wg.Wait()
log.Println("Terminating Bridge")
b.MumbleUsersMutex.Lock()
b.MumbleUsers = make(map[string]bool)
b.MumbleUsersMutex.Unlock()
b.DiscordUsers = make(map[string]discordUser)
}
func (b *BridgeState) discordStatusUpdate() {
2021-01-03 19:49:12 -05:00
m, _ := time.ParseDuration("30s")
for {
time.Sleep(3 * time.Second)
resp, err := gumble.Ping(b.BridgeConfig.MumbleAddr, -1, m)
status := ""
2021-01-03 19:49:12 -05:00
if err != nil {
log.Printf("error pinging mumble server %v\n", err)
b.DiscordSession.UpdateListeningStatus("an error pinging mumble")
} else {
b.MumbleUsersMutex.Lock()
b.BridgeMutex.Lock()
b.MumbleUserCount = resp.ConnectedUsers
if b.Connected {
b.MumbleUserCount = b.MumbleUserCount - 1
2021-01-03 19:49:12 -05:00
}
if b.MumbleUserCount == 0 {
status = "No users in Mumble"
2021-01-03 19:49:12 -05:00
} else {
if len(b.MumbleUsers) > 0 {
status = fmt.Sprintf("%v/%v users in Mumble\n", len(b.MumbleUsers), b.MumbleUserCount)
} else {
status = fmt.Sprintf("%v users in Mumble\n", b.MumbleUserCount)
}
2021-01-03 19:49:12 -05:00
}
b.BridgeMutex.Unlock()
b.MumbleUsersMutex.Unlock()
b.DiscordSession.UpdateListeningStatus(status)
}
}
}
// AutoBridge starts a goroutine to check the number of users in discord and mumble
// when there is at least one user on both, starts up the bridge
// when there are no users on either side, kills the bridge
func (b *BridgeState) AutoBridge() {
log.Println("beginning auto mode")
ticker := time.NewTicker(3 * time.Second)
for {
select {
case <-ticker.C:
case <-b.AutoChanDie:
log.Println("ending automode")
return
}
b.MumbleUsersMutex.Lock()
b.DiscordUsersMutex.Lock()
b.BridgeMutex.Lock()
if !b.Connected && b.MumbleUserCount > 0 && len(b.DiscordUsers) > 0 {
log.Println("users detected in mumble and discord, bridging")
go b.startBridge()
}
if b.Connected && b.MumbleUserCount == 0 && len(b.DiscordUsers) <= 1 {
log.Println("no one online, killing bridge")
b.BridgeDie <- true
}
b.BridgeMutex.Unlock()
b.MumbleUsersMutex.Unlock()
b.DiscordUsersMutex.Unlock()
}
}
func (b *BridgeState) discordSendMessageAll(msg string) {
if b.BridgeConfig.DiscordDisableText {
return
}
b.DiscordUsersMutex.Lock()
for id := range b.DiscordUsers {
du := b.DiscordUsers[id]
if du.dm != nil {
b.DiscordSession.ChannelMessageSend(du.dm.ID, msg)
}
}
b.DiscordUsersMutex.Unlock()
}