TUN-5249: Revert "TUN-5138: Switch to QUIC on auto protocol based on threshold"

This reverts commit e445fd92f7

edgediscovery/protocol.go

@@ -1,50 +1,45 @@
 package edgediscovery
 
 import (
-	"encoding/json"
 	"fmt"
 	"net"
+	"strconv"
 	"strings"
 )
 
 const (
-	protocolRecord = "protocol-v2.argotunnel.com"
+	protocolRecord = "protocol.argotunnel.com"
 )
 
 var (
 	errNoProtocolRecord = fmt.Errorf("No TXT record found for %s to determine connection protocol", protocolRecord)
 )
 
-// ProtocolPercent represents a single Protocol Percentage combination.
-type ProtocolPercent struct {
-	Protocol   string `json:"protocol"`
-	Percentage int32  `json:"percentage"`
-}
-
-// ProtocolPercents represents the preferred distribution ratio of protocols when protocol isn't specified.
-type ProtocolPercents []ProtocolPercent
-
-// GetPercentage returns the threshold percentage of a single protocol.
-func (p ProtocolPercents) GetPercentage(protocol string) int32 {
-	for _, protocolPercent := range p {
-		if strings.ToLower(protocolPercent.Protocol) == strings.ToLower(protocol) {
-			return protocolPercent.Percentage
-		}
-	}
-	return 0
-}
-
-// ProtocolPercentage returns the ratio of protocols and a specification ratio for their selection.
-func ProtocolPercentage() (ProtocolPercents, error) {
+func HTTP2Percentage() (int32, error) {
 	records, err := net.LookupTXT(protocolRecord)
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
 	if len(records) == 0 {
-		return nil, errNoProtocolRecord
+		return 0, errNoProtocolRecord
 	}
-
-	var protocolsWithPercent ProtocolPercents
-	err = json.Unmarshal([]byte(records[0]), &protocolsWithPercent)
-	return protocolsWithPercent, err
+	return parseHTTP2Precentage(records[0])
+}
+
+// The record looks like http2=percentage
+func parseHTTP2Precentage(record string) (int32, error) {
+	const key = "http2"
+	slices := strings.Split(record, "=")
+	if len(slices) != 2 {
+		return 0, fmt.Errorf("Malformed TXT record %s, expect http2=percentage", record)
+	}
+	if slices[0] != key {
+		return 0, fmt.Errorf("Incorrect key %s, expect %s", slices[0], key)
+	}
+	percentage, err := strconv.ParseInt(slices[1], 10, 32)
+	if err != nil {
+		return 0, err
+	}
+	return int32(percentage), nil
+
 }

edgediscovery/protocol_test.go

@@ -6,7 +6,75 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestProtocolPercentage(t *testing.T) {
-	_, err := ProtocolPercentage()
+func TestHTTP2Percentage(t *testing.T) {
+	_, err := HTTP2Percentage()
 	assert.NoError(t, err)
 }
+
+func TestParseHTTP2Precentage(t *testing.T) {
+	tests := []struct {
+		record     string
+		percentage int32
+		wantErr    bool
+	}{
+		{
+			record:     "http2=-1",
+			percentage: -1,
+			wantErr:    false,
+		},
+		{
+			record:     "http2=0",
+			percentage: 0,
+			wantErr:    false,
+		},
+		{
+			record:     "http2=50",
+			percentage: 50,
+			wantErr:    false,
+		},
+		{
+			record:     "http2=100",
+			percentage: 100,
+			wantErr:    false,
+		},
+		{
+			record:     "http2=1000",
+			percentage: 1000,
+			wantErr:    false,
+		},
+		{
+			record:  "http2=10.5",
+			wantErr: true,
+		},
+		{
+			record:  "http2=10 h2mux=90",
+			wantErr: true,
+		},
+		{
+			record:  "http2=ten",
+			wantErr: true,
+		},
+
+		{
+			record:  "h2mux=100",
+			wantErr: true,
+		},
+		{
+			record:  "http2",
+			wantErr: true,
+		},
+		{
+			record:  "http2=",
+			wantErr: true,
+		},
+	}
+
+	for _, test := range tests {
+		p, err := parseHTTP2Precentage(test.record)
+		if test.wantErr {
+			assert.Error(t, err)
+		} else {
+			assert.Equal(t, test.percentage, p)
+		}
+	}
+}