mos licensing implementation

CL: mos licensing implementation

PUBLISHED_FROM=60db4b16af57d8938a8922fd78b435d5b34d3995

mos/call.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"cesanta.com/mos/dev"
+	"cesanta.com/mos/flags"
 
 	"github.com/cesanta/errors"
 	flag "github.com/spf13/pflag"
@@ -46,9 +47,9 @@ func call(ctx context.Context, devConn *dev.DevConn) error {
 		params = args[1]
 	}
 
-	if *timeout > 0 {
+	if *flags.Timeout > 0 {
 		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, *timeout)
+		ctx, cancel = context.WithTimeout(ctx, *flags.Timeout)
 		defer cancel()
 	}
 

mos/console.go

@@ -20,6 +20,8 @@ import (
 	"cesanta.com/common/go/ourjson"
 	"cesanta.com/mos/debug_core_dump"
 	"cesanta.com/mos/dev"
+	"cesanta.com/mos/devutil"
+	"cesanta.com/mos/flags"
 	"cesanta.com/mos/timestamp"
 
 	"github.com/cesanta/errors"
@@ -42,11 +44,8 @@ var (
 )
 
 func init() {
-	flag.UintVar(&baudRateFlag, "baud-rate", 115200, "Serial port speed")
 	flag.BoolVar(&noInput, "no-input", false,
 		"Do not read from stdin, only print device's output to stdout")
-	flag.BoolVar(&hwFCFlag, "hw-flow-control", false, "Enable hardware flow control (CTS/RTS)")
-	flag.BoolVar(&setControlLines, "set-control-lines", true, "Set RTS and DTR explicitly when in console/RPC mode")
 	flag.BoolVar(&catchCoreDumps, "catch-core-dumps", true, "Catch and save core dumps")
 
 	flag.StringVar(&tsfSpec, "timestamp", "StampMilli",
@@ -149,15 +148,15 @@ func console(ctx context.Context, devConn *dev.DevConn) error {
 	var r io.Reader
 	var w io.Writer
 
-	purl, err := url.Parse(*portFlag)
+	purl, err := url.Parse(*flags.Port)
 	switch {
 	case err == nil && (purl.Scheme == "mqtt" || purl.Scheme == "mqtts"):
 		chr := &chanReader{rch: make(chan []byte)}
-		opts, topic, err := codec.MQTTClientOptsFromURL(*portFlag, "", "", "")
+		opts, topic, err := codec.MQTTClientOptsFromURL(*flags.Port, "", "", "")
 		if err != nil {
 			return errors.Errorf("invalid MQTT port URL format")
 		}
-		tlsConfig, err := tlsConfigFromFlags()
+		tlsConfig, err := flags.TLSConfigFromFlags()
 		if err != nil {
 			return errors.Annotatef(err, "inavlid TLS config")
 		}
@@ -212,7 +211,7 @@ func console(ctx context.Context, devConn *dev.DevConn) error {
 	case err == nil && (purl.Scheme == "ws" || purl.Scheme == "wss"):
 		// Connect to mDash and activate event forwarding.
 		chr := &chanReader{rch: make(chan []byte)}
-		devConn, err = createDevConn(ctx)
+		devConn, err = devutil.CreateDevConnFromFlags(ctx)
 		if err != nil {
 			return errors.Trace(err)
 		}
@@ -247,15 +246,15 @@ func console(ctx context.Context, devConn *dev.DevConn) error {
 
 	default:
 		// Everything else is treated as a serial port.
-		port, err := getPort()
+		port, err := devutil.GetPort()
 		if err != nil {
 			return errors.Trace(err)
 		}
 
 		sp, err := serial.Open(serial.OpenOptions{
 			PortName:            port,
-			BaudRate:            baudRateFlag,
-			HardwareFlowControl: hwFCFlag,
+			BaudRate:            uint(*flags.BaudRate),
+			HardwareFlowControl: *flags.HWFC,
 			DataBits:            8,
 			ParityMode:          serial.PARITY_NONE,
 			StopBits:            1,
@@ -264,8 +263,8 @@ func console(ctx context.Context, devConn *dev.DevConn) error {
 		if err != nil {
 			return errors.Annotatef(err, "failed to open %s", port)
 		}
-		if setControlLines || *invertedControlLines {
-			bFalse := *invertedControlLines
+		if *flags.SetControlLines || *flags.InvertedControlLines {
+			bFalse := *flags.InvertedControlLines
 			sp.SetDTR(bFalse)
 			sp.SetRTS(bFalse)
 		}

mos/devutil/devutil.go

@@ -0,0 +1,81 @@
+package devutil
+
+import (
+	"context"
+	"crypto/tls"
+	"runtime"
+	"strings"
+	"time"
+
+	"cesanta.com/common/go/mgrpc/codec"
+	"cesanta.com/mos/dev"
+	"cesanta.com/mos/flags"
+	"cesanta.com/mos/watson"
+	"github.com/cesanta/errors"
+)
+
+func createDevConnWithJunkHandler(ctx context.Context, junkHandler func(junk []byte)) (*dev.DevConn, error) {
+	port, err := GetPort()
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	c := dev.Client{Port: port, Timeout: *flags.Timeout, Reconnect: *flags.Reconnect}
+	prefix := "serial://"
+	if strings.Index(port, "://") > 0 {
+		prefix = ""
+	}
+	addr := prefix + port
+
+	// Init and pass TLS config if --cert-file and --key-file are specified
+	var tlsConfig *tls.Config
+	if *flags.CertFile != "" ||
+		strings.HasPrefix(port, "wss") ||
+		strings.HasPrefix(port, "https") ||
+		strings.HasPrefix(port, "mqtts") {
+
+		tlsConfig, err = flags.TLSConfigFromFlags()
+		if err != nil {
+			return nil, errors.Trace(err)
+		}
+	}
+
+	codecOpts := &codec.Options{
+		AzureDM: codec.AzureDMCodecOptions{
+			ConnectionString: *flags.AzureConnectionString,
+		},
+		MQTT: codec.MQTTCodecOptions{},
+		Serial: codec.SerialCodecOptions{
+			BaudRate:             uint(*flags.BaudRate),
+			HardwareFlowControl:  *flags.HWFC,
+			JunkHandler:          junkHandler,
+			SetControlLines:      *flags.SetControlLines,
+			InvertedControlLines: *flags.InvertedControlLines,
+		},
+		Watson: codec.WatsonCodecOptions{
+			APIKey:       watson.WatsonAPIKeyFlag,
+			APIAuthToken: watson.WatsonAPIAuthTokenFlag,
+		},
+	}
+	// Due to lack of flow control, we send data in chunks and wait after each.
+	// At non-default baud rate we assume user knows what they are doing.
+	if !codecOpts.Serial.HardwareFlowControl &&
+		codecOpts.Serial.BaudRate == 115200 &&
+		!*flags.RPCUARTNoDelay {
+		codecOpts.Serial.SendChunkSize = 16
+		codecOpts.Serial.SendChunkDelay = 5 * time.Millisecond
+		// So, this is weird. ST-Link serial device seems to have issues on Mac OS X if we write too fast.
+		// Yes, even 16 bytes at 5 ms interval is too fast, and 8 bytes too. It looks like this:
+		// processes trying to access /dev/cu.usbmodemX get stuck and the only re-plugging
+		// (or re-enumerating) gets it out of this state.
+		// Hence, the following kludge.
+		if runtime.GOOS == "darwin" && strings.Contains(port, "cu.usbmodem") {
+			codecOpts.Serial.SendChunkSize = 6
+		}
+	}
+	devConn, err := c.CreateDevConnWithOpts(ctx, addr, *flags.Reconnect, tlsConfig, codecOpts)
+	return devConn, errors.Trace(err)
+}
+
+func CreateDevConnFromFlags(ctx context.Context) (*dev.DevConn, error) {
+	return createDevConnWithJunkHandler(ctx, func(junk []byte) {})
+}

mos/serial.go → mos/devutil/serial.go

@@ -1,21 +1,24 @@
-package main
+package devutil
 
 import (
 	"github.com/cesanta/errors"
+
+	"cesanta.com/common/go/ourutil"
+	"cesanta.com/mos/flags"
 )
 
 var defaultPort string
 
-func getPort() (string, error) {
-	if *portFlag != "auto" {
-		return *portFlag, nil
+func GetPort() (string, error) {
+	if *flags.Port != "auto" {
+		return *flags.Port, nil
 	}
 	if defaultPort == "" {
 		defaultPort = getDefaultPort()
 		if defaultPort == "" {
 			return "", errors.Errorf("--port not specified and none were found")
 		}
-		reportf("Using port %s", defaultPort)
+		ourutil.Reportf("Using port %s", defaultPort)
 	}
 	return defaultPort, nil
 }

mos/devutil/serial_darwin.go

@@ -0,0 +1,21 @@
+package devutil
+
+import (
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+func EnumerateSerialPorts() []string {
+	list, _ := filepath.Glob("/dev/cu.*")
+	var filteredList []string
+	for _, s := range list {
+		if !strings.Contains(s, "Bluetooth-") &&
+			!strings.Contains(s, "-SPPDev") &&
+			!strings.Contains(s, "-WirelessiAP") {
+			filteredList = append(filteredList, s)
+		}
+	}
+	sort.Strings(filteredList)
+	return filteredList
+}

mos/devutil/serial_linux.go

@@ -0,0 +1,15 @@
+package devutil
+
+import (
+	"path/filepath"
+	"sort"
+)
+
+func EnumerateSerialPorts() []string {
+	// Note: Prefer ttyUSB* to ttyACM*.
+	list1, _ := filepath.Glob("/dev/ttyUSB*")
+	sort.Strings(list1)
+	list2, _ := filepath.Glob("/dev/ttyACM*")
+	sort.Strings(list2)
+	return append(list1, list2...)
+}

mos/os_posix.go → mos/devutil/serial_posix.go

@@ -1,9 +1,9 @@
 // +build !windows
 
-package main
+package devutil
 
 func getDefaultPort() string {
-	ports := enumerateSerialPorts()
+	ports := EnumerateSerialPorts()
 	if len(ports) == 0 {
 		return ""
 	}