func (k *Mumble) Start(fl map[string]string, s *services.Services) {
k.services = s
//Config
k.Config = gumble.NewConfig()
k.Config.Username = fl["Flag_mumble_username"]
k.Config.Password = fl["Flag_mumble_password"]
k.Config.Address = fl["Flag_mumble_server"]
k.Config.TLSConfig.InsecureSkipVerify = true
k.conf_volume = 1.0
//Client creation
k.Client = gumble.NewClient(k.Config)
//Attach listeners
k.Client.Attach(gumbleutil.AutoBitrate)
k.Client.Attach(k)
//TLS
if fl["Flag_mumble_cert_lock"] != "" {
gumbleutil.CertificateLockFile(k.Client, fl["Flag_mumble_cert_lock"])
}
if _, err := os.Stat("./config/Kotik.pem"); err == nil && fl["Flag_dev"] == "false" {
fl["Flag_mumble_cert"] = "./config/Kotik.pem"
} else if _, err := os.Stat("./config/Kotik-dev.pem"); err == nil && fl["Flag_dev"] == "true" {
fl["Flag_mumble_cert"] = "./config/Kotik-dev.pem"
}
if fl["Flag_mumble_cert"] != "" {
if fl["Flag_mumble_cert_key"] == "" {
fl["Flag_mumble_cert_key"] = fl["Flag_mumble_cert"]
}
if certificate, err := tls.LoadX509KeyPair(fl["Flag_mumble_cert"], fl["Flag_mumble_cert_key"]); err != nil {
panic(err)
} else {
k.Config.TLSConfig.Certificates = append(k.Config.TLSConfig.Certificates, certificate)
}
}
//Connect
flag := false
for flag == false {
if err := k.Client.Connect(); err != nil {
time.Sleep(time.Second * 5)
} else {
flag = true
}
}
}
// main primarily performs startup tasks. Grabs and parses commandline
// args, sets up the gumble client and its listeners, and then connects to the server.
func main() {
if currentUser, err := user.Current(); err == nil {
dj.homeDir = currentUser.HomeDir
}
if err := loadConfiguration(); err == nil {
fmt.Println("Configuration successfully loaded!")
} else {
panic(err)
}
var address, port, username, password, channel, pemCert, pemKey, accesstokens string
var insecure bool
var version bool
flag.StringVar(&address, "server", "localhost", "address for Mumble server")
flag.StringVar(&port, "port", "64738", "port for Mumble server")
flag.StringVar(&username, "username", "MumbleDJ", "username of MumbleDJ on server")
flag.StringVar(&password, "password", "", "password for Mumble server (if needed)")
flag.StringVar(&channel, "channel", "root", "default channel for MumbleDJ")
flag.StringVar(&pemCert, "cert", "", "path to user PEM certificate for MumbleDJ")
flag.StringVar(&pemKey, "key", "", "path to user PEM key for MumbleDJ")
flag.StringVar(&accesstokens, "accesstokens", "", "list of access tokens for channel auth")
flag.BoolVar(&insecure, "insecure", false, "skip certificate checking")
flag.BoolVar(&version, "version", false, "show version")
flag.Parse()
if version {
fmt.Printf("MumbleDJ %s\n", VERSION)
os.Exit(0)
}
dj.config = gumble.Config{
Username: username,
Password: password,
Address: address + ":" + port,
Tokens: strings.Split(accesstokens, " "),
}
dj.client = gumble.NewClient(&dj.config)
dj.config.TLSConfig.InsecureSkipVerify = true
if !insecure {
gumbleutil.CertificateLockFile(dj.client, fmt.Sprintf("%s/.mumbledj/cert.lock", dj.homeDir))
}
if pemCert != "" {
if pemKey == "" {
pemKey = pemCert
}
if certificate, err := tls.LoadX509KeyPair(pemCert, pemKey); err != nil {
panic(err)
} else {
dj.config.TLSConfig.Certificates = append(dj.config.TLSConfig.Certificates, certificate)
}
}
dj.defaultChannel = strings.Split(channel, "/")
services = append(services, Mixcloud{})
CheckAPIKeys()
dj.client.Attach(gumbleutil.Listener{
Connect: dj.OnConnect,
Disconnect: dj.OnDisconnect,
TextMessage: dj.OnTextMessage,
UserChange: dj.OnUserChange,
})
dj.client.Attach(gumbleutil.AutoBitrate)
if err := dj.client.Connect(); err != nil {
fmt.Printf("Could not connect to Mumble server at %s:%s.\n", address, port)
os.Exit(1)
}
<-dj.keepAlive
}
//main parses command line argument and sets up the bot to connect
func main() {
YouTubeAPICheck()
if currentUser, err := user.Current(); err == nil {
jew.homeDir = currentUser.HomeDir
}
if err := loadConfiguration(); err == nil {
fmt.Println("Config loaded successfully!")
} else {
panic(err)
}
var address, port, username, password, pemCert, pemKey, accesstokens string
var insecure bool
flag.StringVar(&address, "server", "localhost", "addres of Mumble server")
flag.StringVar(&port, "port", "64738", "port for Mumble server")
flag.StringVar(&username, "username", "Jewvis", "username of bot")
flag.StringVar(&password, "password", "", "password for Mumble server")
flag.StringVar(&pemCert, "certificate", "", "path to PEM certificate")
flag.StringVar(&pemKey, "key", "", "path to PEM key")
flag.StringVar(&accesstokens, "accesstokens", "", "list of access tokens")
flag.BoolVar(&insecure, "insecure", false, "skip certificate checking")
flag.Parse()
jew.config = gumble.Config{
Username: username,
Password: password,
Address: address + ":" + port,
Tokens: strings.Split(accesstokens, " "),
}
jew.client = gumble.NewClient(&jew.config)
jew.config.TLSConfig.InsecureSkipVerify = true
if !insecure {
gumbleutil.CertificateLockFile(jew.client, fmt.Sprintf("%s/jewvis/cert.lock", jew.homeDir))
}
if pemCert != "" {
if pemKey == "" {
pemKey = pemCert
}
if certificate, err := tls.LoadX509KeyPair(pemCert, pemKey); err != nil {
panic(err)
} else {
jew.config.TLSConfig.Certificates = append(jew.config.TLSConfig.Certificates, certificate)
}
}
jew.client.Attach(gumbleutil.Listener{
Connect: jew.OnConnect,
Disconnect: jew.OnDisconnect,
TextMessage: jew.OnTextMessage,
UserChange: jew.OnUserChange,
})
if err := jew.client.Connect(); err != nil {
fmt.Print("Could not connect to server );", err)
os.Exit(1)
}
<-jew.keepAlive
}
func main() {
// Flags
username := flag.String("username", "piepan-bot", "username of the bot")
password := flag.String("password", "", "user password")
server := flag.String("server", "localhost:64738", "address of the server")
certificateFile := flag.String("certificate", "", "user certificate file (PEM)")
keyFile := flag.String("key", "", "user certificate key file (PEM)")
insecure := flag.Bool("insecure", false, "skip certificate checking")
lock := flag.String("lock", "", "server certificate lock file")
ffmpeg := flag.String("ffmpeg", "ffmpeg", "ffmpeg-capable executable for media streaming")
var accessTokens strFlagSlice
flag.Var(&accessTokens, "access-token", "server access token (can be defined multiple times)")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "piepan v0.7.0\n")
fmt.Fprintf(os.Stderr, "usage: %s [options] [script files]\n", os.Args[0])
fmt.Fprintf(os.Stderr, "an easy to use framework for writing scriptable Mumble bots\n")
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\nScript files are defined in the following way:\n")
fmt.Fprintf(os.Stderr, " [type%c[environment%c]]filename\n", os.PathListSeparator, os.PathListSeparator)
fmt.Fprintf(os.Stderr, " filename: path to script file\n")
fmt.Fprintf(os.Stderr, " type: type of script file (default: file extension)\n")
fmt.Fprintf(os.Stderr, " environment: name of environment where script will be executed (default: type)\n\n")
fmt.Fprintf(os.Stderr, "Enabled script types:\n")
fmt.Fprintf(os.Stderr, " Type Name\n")
for _, ext := range piepan.PluginExtensions {
fmt.Fprintf(os.Stderr, " %-12s %s\n", ext, piepan.Plugins[ext].Name)
}
}
flag.Parse()
// Configuration
config := gumble.NewConfig()
config.Username = *username
config.Password = *password
config.Address = *server
config.Tokens = gumble.AccessTokens(accessTokens)
client := gumble.NewClient(config)
instance := piepan.New(client)
audio := gumble_ffmpeg.New(client)
audio.Command = *ffmpeg
instance.Audio = audio
if *insecure {
config.TLSConfig.InsecureSkipVerify = true
}
if *lock != "" {
gumbleutil.CertificateLockFile(client, *lock)
}
if *certificateFile != "" {
if *keyFile == "" {
keyFile = certificateFile
}
if certificate, err := tls.LoadX509KeyPair(*certificateFile, *keyFile); err != nil {
panic(err)
} else {
config.TLSConfig.Certificates = append(config.TLSConfig.Certificates, certificate)
}
}
client.Attach(gumbleutil.AutoBitrate)
// Load scripts
for _, script := range flag.Args() {
if err := instance.LoadScript(script); err != nil {
fmt.Fprintf(os.Stderr, "%s: %s\n", script, err)
}
}
keepAlive := make(chan bool)
exitStatus := 0
client.Attach(gumbleutil.Listener{
Disconnect: func(e *gumble.DisconnectEvent) {
if e.Type != gumble.DisconnectUser {
exitStatus = int(e.Type) + 1
}
keepAlive <- true
},
})
if err := client.Connect(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
<-keepAlive
os.Exit(exitStatus)
}
func main() {
// Flags
username := flag.String("username", "piepan-bot", "username of the bot")
password := flag.String("password", "", "user password")
server := flag.String("server", "localhost:64738", "address of the server")
certificateFile := flag.String("certificate", "", "user certificate file (PEM)")
keyFile := flag.String("key", "", "user certificate key file (PEM)")
insecure := flag.Bool("insecure", false, "skip certificate checking")
lock := flag.String("lock", "", "server certificate lock file")
ffmpeg := flag.String("ffmpeg", "ffmpeg", "ffmpeg-capable executable for media streaming")
var accessTokens strFlagSlice
flag.Var(&accessTokens, "access-token", "server access token (can be defined multiple times)")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "piepan v0.9.0\n")
fmt.Fprintf(os.Stderr, "usage: %s [options] [script files]\n", os.Args[0])
fmt.Fprintf(os.Stderr, "an easy to use framework for writing Mumble bots using Lua\n")
flag.PrintDefaults()
}
flag.Parse()
// Configuration
config := gumble.NewConfig()
config.Username = *username
config.Password = *password
config.Address = *server
config.Tokens = gumble.AccessTokens(accessTokens)
client := gumble.NewClient(config)
instance := piepan.New(client)
instance.AudioCommand = *ffmpeg
if *insecure {
config.TLSConfig.InsecureSkipVerify = true
}
if *lock != "" {
gumbleutil.CertificateLockFile(client, *lock)
}
if *certificateFile != "" {
if *keyFile == "" {
keyFile = certificateFile
}
certificate, err := tls.LoadX509KeyPair(*certificateFile, *keyFile)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
config.TLSConfig.Certificates = append(config.TLSConfig.Certificates, certificate)
}
client.Attach(gumbleutil.AutoBitrate)
// Load scripts
for _, script := range flag.Args() {
if err := instance.LoadFile(script); err != nil {
fmt.Fprintf(os.Stderr, "%s: %s\n", script, err)
}
}
keepAlive := make(chan bool)
exitStatus := 0
client.Attach(gumbleutil.Listener{
Disconnect: func(e *gumble.DisconnectEvent) {
if e.Type != gumble.DisconnectUser {
exitStatus = int(e.Type) + 1
}
keepAlive <- true
},
})
if err := client.Connect(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err)
os.Exit(1)
}
<-keepAlive
os.Exit(exitStatus)
}
