implement wicectl client to control the daemon via gRPC

Signed-off-by: Steffen Vogel <post@steffenvogel.de>

internal/config/types.go

@@ -0,0 +1,180 @@
+package config
+
+import (
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+
+	"github.com/pion/ice/v2"
+	"go.uber.org/zap"
+	"riasc.eu/wice/pkg/proxy"
+)
+
+type backendURLList []*url.URL
+
+func (i *backendURLList) Type() string {
+	return "stringSlice"
+}
+
+func (i *backendURLList) String() string {
+	s := []string{}
+	for _, u := range *i {
+		s = append(s, u.String())
+	}
+
+	return strings.Join(s, ",")
+}
+
+func (i *backendURLList) Set(value string) error {
+
+	// Allow the user to specify just the backend type as a valid url.
+	// E.g. "p2p" instead of "p2p:"
+	if !strings.Contains(value, ":") {
+		value += ":"
+	}
+
+	uri, err := url.Parse(value)
+	if err != nil {
+		return fmt.Errorf("invalid backend URI: %w", err)
+	}
+
+	*i = append(*i, uri)
+
+	return nil
+}
+
+type arrayFlags []string
+
+func (i *arrayFlags) String() string {
+	return strings.Join(*i, ",")
+}
+
+func (i *arrayFlags) Set(value string) error {
+	*i = append(*i, value)
+	return nil
+}
+
+func (i *arrayFlags) Type() string {
+	return "stringSlice"
+}
+
+type iceURLList []*ice.URL
+
+func (ul *iceURLList) Type() string {
+	return "stringSlice"
+}
+
+func (ul *iceURLList) Set(value string) error {
+	u, err := ice.ParseURL(value)
+	if err != nil {
+		return err
+	}
+
+	*ul = append(*ul, u)
+
+	return nil
+}
+
+func (ul *iceURLList) String() string {
+	l := []string{}
+
+	for _, u := range *ul {
+		l = append(l, u.String())
+	}
+
+	return strings.Join(l, ",")
+}
+
+type candidateTypeList []ice.CandidateType
+
+func (cl *candidateTypeList) Type() string {
+	return "stringSlice"
+}
+
+func (cl *candidateTypeList) Set(value string) error {
+	ct, err := candidateTypeFromString(value)
+	if err != nil {
+		return err
+	}
+
+	*cl = append(*cl, ct)
+
+	return nil
+}
+
+func (cl *candidateTypeList) String() string {
+	l := []string{}
+
+	for _, c := range *cl {
+		l = append(l, c.String())
+	}
+
+	return strings.Join(l, ",")
+}
+
+type networkTypeList []ice.NetworkType
+
+func (nl *networkTypeList) Type() string {
+	return "stringSlice"
+}
+
+func (nl *networkTypeList) Set(value string) error {
+	ct, err := networkTypeFromString(value)
+	if err != nil {
+		return err
+	}
+
+	*nl = append(*nl, ct)
+
+	return nil
+}
+
+func (nl *networkTypeList) String() string {
+	l := []string{}
+
+	for _, c := range *nl {
+		l = append(l, c.String())
+	}
+
+	return strings.Join(l, ",")
+}
+
+type proxyType struct{ proxy.ProxyType }
+
+func (pt *proxyType) Type() string {
+	return "string"
+}
+
+func (pt *proxyType) Set(value string) error {
+	var err error
+	pt.ProxyType, err = proxy.ProxyTypeFromString(value)
+	return err
+}
+
+type logLevel struct{ zap.AtomicLevel }
+
+func (ll *logLevel) Type() string {
+	return "string"
+}
+
+func (ll *logLevel) Set(value string) error {
+	return ll.UnmarshalText([]byte(value))
+}
+
+type regex struct{ *regexp.Regexp }
+
+func (re *regex) Type() string {
+	return "string"
+}
+
+func (re *regex) Set(value string) error {
+	r, err := regexp.Compile(value)
+	if err != nil {
+		return fmt.Errorf("failed to compile regex: %w", err)
+	}
+
+	re.Regexp = r
+
+	return nil
+}