major refactor.

internal/config/capture.go

@@ -0,0 +1,145 @@
+package config
+
+import (
+	"regexp"
+	"strconv"
+
+	"github.com/pion/webrtc/v2"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type Capture struct {
+	Display      string
+	Device       string
+	AudioCodec   string
+	AudioParams  string
+	VideoCodec   string
+	VideoParams  string
+	ScreenWidth  int
+	ScreenHeight int
+	ScreenRate   int
+	BroadcastPipeline string
+}
+
+func (Capture) Init(cmd *cobra.Command) error {
+	cmd.PersistentFlags().String("display", ":99.0", "XDisplay to capture")
+	if err := viper.BindPFlag("display", cmd.PersistentFlags().Lookup("display")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("device", "auto_null.monitor", "audio device to capture")
+	if err := viper.BindPFlag("device", cmd.PersistentFlags().Lookup("device")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("audio", "", "audio codec parameters to use for streaming")
+	if err := viper.BindPFlag("audio", cmd.PersistentFlags().Lookup("audio")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("video", "", "video codec parameters to use for streaming")
+	if err := viper.BindPFlag("video", cmd.PersistentFlags().Lookup("video")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("screen", "1280x720@30", "default screen resolution and framerate")
+	if err := viper.BindPFlag("screen", cmd.PersistentFlags().Lookup("screen")); err != nil {
+		return err
+	}
+
+	// video codecs
+	cmd.PersistentFlags().Bool("vp8", false, "use VP8 video codec")
+	if err := viper.BindPFlag("vp8", cmd.PersistentFlags().Lookup("vp8")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("vp9", false, "use VP9 video codec")
+	if err := viper.BindPFlag("vp9", cmd.PersistentFlags().Lookup("vp9")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("h264", false, "use H264 video codec")
+	if err := viper.BindPFlag("h264", cmd.PersistentFlags().Lookup("h264")); err != nil {
+		return err
+	}
+
+	// audio codecs
+	cmd.PersistentFlags().Bool("opus", false, "use Opus audio codec")
+	if err := viper.BindPFlag("opus", cmd.PersistentFlags().Lookup("opus")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("g722", false, "use G722 audio codec")
+	if err := viper.BindPFlag("g722", cmd.PersistentFlags().Lookup("g722")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("pcmu", false, "use PCMU audio codec")
+	if err := viper.BindPFlag("pcmu", cmd.PersistentFlags().Lookup("pcmu")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("pcma", false, "use PCMA audio codec")
+	if err := viper.BindPFlag("pcma", cmd.PersistentFlags().Lookup("pcma")); err != nil {
+		return err
+	}
+
+	// broadcast
+	cmd.PersistentFlags().String("broadcast_pipeline", "", "audio video codec parameters to use for broadcasting")
+	if err := viper.BindPFlag("broadcast_pipeline", cmd.PersistentFlags().Lookup("broadcast_pipeline")); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Capture) Set() {
+	videoCodec := webrtc.VP8
+	if viper.GetBool("vp8") {
+		videoCodec = webrtc.VP8
+	} else if viper.GetBool("vp9") {
+		videoCodec = webrtc.VP9
+	} else if viper.GetBool("h264") {
+		videoCodec = webrtc.H264
+	}
+
+	audioCodec := webrtc.Opus
+	if viper.GetBool("opus") {
+		audioCodec = webrtc.Opus
+	} else if viper.GetBool("g722") {
+		audioCodec = webrtc.G722
+	} else if viper.GetBool("pcmu") {
+		audioCodec = webrtc.PCMU
+	} else if viper.GetBool("pcma") {
+		audioCodec = webrtc.PCMA
+	}
+
+	s.Device = viper.GetString("device")
+	s.AudioCodec = audioCodec
+	s.AudioParams = viper.GetString("audio")
+	s.Display = viper.GetString("display")
+	s.VideoCodec = videoCodec
+	s.VideoParams = viper.GetString("video")
+
+	s.ScreenWidth = 1280
+	s.ScreenHeight = 720
+	s.ScreenRate = 30
+
+	r := regexp.MustCompile(`([0-9]{1,4})x([0-9]{1,4})@([0-9]{1,3})`)
+	res := r.FindStringSubmatch(viper.GetString("screen"))
+
+	if len(res) > 0 {
+		width, err1 := strconv.ParseInt(res[1], 10, 64)
+		height, err2 := strconv.ParseInt(res[2], 10, 64)
+		rate, err3 := strconv.ParseInt(res[3], 10, 64)
+
+		if err1 == nil && err2 == nil && err3 == nil {
+			s.ScreenWidth = int(width)
+			s.ScreenHeight = int(height)
+			s.ScreenRate = int(rate)
+		}
+	}
+
+	s.BroadcastPipeline = viper.GetString("broadcast_pipeline")
+}

internal/config/config.go

@@ -0,0 +1,8 @@
+package config
+
+import "github.com/spf13/cobra"
+
+type Config interface {
+	Init(cmd *cobra.Command) error
+	Set()
+}

internal/config/root.go

@@ -0,0 +1,37 @@
+package config
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type Root struct {
+	Debug   bool
+	Logs    bool
+	CfgFile string
+}
+
+func (Root) Init(cmd *cobra.Command) error {
+	cmd.PersistentFlags().BoolP("debug", "d", false, "enable debug mode")
+	if err := viper.BindPFlag("debug", cmd.PersistentFlags().Lookup("debug")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().BoolP("logs", "l", false, "save logs to file")
+	if err := viper.BindPFlag("logs", cmd.PersistentFlags().Lookup("logs")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("config", "", "configuration file path")
+	if err := viper.BindPFlag("config", cmd.PersistentFlags().Lookup("config")); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Root) Set() {
+	s.Logs = viper.GetBool("logs")
+	s.Debug = viper.GetBool("debug")
+	s.CfgFile = viper.GetString("config")
+}

internal/config/server.go

@@ -0,0 +1,58 @@
+package config
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type Server struct {
+	Cert   string
+	Key    string
+	Bind   string
+	Static string
+	UserToken  string
+	AdminToken string
+}
+
+func (Server) Init(cmd *cobra.Command) error {
+	cmd.PersistentFlags().String("bind", "127.0.0.1:8080", "address/port/socket to serve neko")
+	if err := viper.BindPFlag("bind", cmd.PersistentFlags().Lookup("bind")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("cert", "", "path to the SSL cert used to secure the neko server")
+	if err := viper.BindPFlag("cert", cmd.PersistentFlags().Lookup("cert")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("key", "", "path to the SSL key used to secure the neko server")
+	if err := viper.BindPFlag("key", cmd.PersistentFlags().Lookup("key")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("static", "./www", "path to neko client files to serve")
+	if err := viper.BindPFlag("static", cmd.PersistentFlags().Lookup("static")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("user_token", "user_secret", "JWT token for users")
+	if err := viper.BindPFlag("user_token", cmd.PersistentFlags().Lookup("user_token")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("admin_token", "admin_secret", "JWT token for admins")
+	if err := viper.BindPFlag("admin_token", cmd.PersistentFlags().Lookup("admin_token")); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Server) Set() {
+	s.Cert = viper.GetString("cert")
+	s.Key = viper.GetString("key")
+	s.Bind = viper.GetString("bind")
+	s.Static = viper.GetString("static")
+	s.UserToken = viper.GetString("user_token")
+	s.AdminToken = viper.GetString("admin_token")
+}

internal/config/webrtc.go

@@ -0,0 +1,79 @@
+package config
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"demodesk/neko/internal/utils"
+)
+
+type WebRTC struct {
+	ICELite      bool
+	ICEServers   []string
+	EphemeralMin uint16
+	EphemeralMax uint16
+	NAT1To1IPs   []string
+}
+
+func (WebRTC) Init(cmd *cobra.Command) error {
+	cmd.PersistentFlags().String("epr", "59000-59100", "limits the pool of ephemeral ports that ICE UDP connections can allocate from")
+	if err := viper.BindPFlag("epr", cmd.PersistentFlags().Lookup("epr")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().StringSlice("nat1to1", []string{}, "sets a list of external IP addresses of 1:1 (D)NAT and a candidate type for which the external IP address is used")
+	if err := viper.BindPFlag("nat1to1", cmd.PersistentFlags().Lookup("nat1to1")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("icelite", false, "configures whether or not the ice agent should be a lite agent")
+	if err := viper.BindPFlag("icelite", cmd.PersistentFlags().Lookup("icelite")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().StringSlice("iceserver", []string{"stun:stun.l.google.com:19302"}, "describes a single STUN and TURN server that can be used by the ICEAgent to establish a connection with a peer")
+	if err := viper.BindPFlag("iceserver", cmd.PersistentFlags().Lookup("iceserver")); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *WebRTC) Set() {
+	s.ICELite = viper.GetBool("icelite")
+	s.ICEServers = viper.GetStringSlice("iceserver")
+	s.NAT1To1IPs = viper.GetStringSlice("nat1to1")
+
+	if len(s.NAT1To1IPs) == 0 {
+		ip, err := utils.GetIP()
+		if err == nil {
+			s.NAT1To1IPs = append(s.NAT1To1IPs, ip)
+		}
+	}
+
+	min := uint16(59000)
+	max := uint16(59100)
+	epr := viper.GetString("epr")
+	ports := strings.SplitN(epr, "-", -1)
+	if len(ports) > 1 {
+		start, err := strconv.ParseUint(ports[0], 10, 16)
+		if err == nil {
+			min = uint16(start)
+		}
+
+		end, err := strconv.ParseUint(ports[1], 10, 16)
+		if err == nil {
+			max = uint16(end)
+		}
+	}
+
+	if min > max {
+		s.EphemeralMin = max
+		s.EphemeralMax = min
+	} else {
+		s.EphemeralMin = min
+		s.EphemeralMax = max
+	}
+}

internal/config/websocket.go

@@ -0,0 +1,37 @@
+package config
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+type WebSocket struct {
+	Password      string
+	AdminPassword string
+	Proxy         bool
+}
+
+func (WebSocket) Init(cmd *cobra.Command) error {
+	cmd.PersistentFlags().String("password", "neko", "password for connecting to stream")
+	if err := viper.BindPFlag("password", cmd.PersistentFlags().Lookup("password")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().String("password_admin", "admin", "admin password for connecting to stream")
+	if err := viper.BindPFlag("password_admin", cmd.PersistentFlags().Lookup("password_admin")); err != nil {
+		return err
+	}
+
+	cmd.PersistentFlags().Bool("proxy", false, "enable reverse proxy mode")
+	if err := viper.BindPFlag("proxy", cmd.PersistentFlags().Lookup("proxy")); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *WebSocket) Set() {
+	s.Password = viper.GetString("password")
+	s.AdminPassword = viper.GetString("password_admin")
+	s.Proxy = viper.GetBool("proxy")
+}