add some ut

Author: cvvz

pkg/blobfuse-proxy/main.go

@@ -23,9 +23,7 @@ import (
 
 	"k8s.io/klog/v2"
 
-	"github.com/go-ini/ini"
-	"github.com/pkg/errors"
-	server "sigs.k8s.io/blob-csi-driver/pkg/blobfuse-proxy/server"
+	"sigs.k8s.io/blob-csi-driver/pkg/blobfuse-proxy/server"
 	csicommon "sigs.k8s.io/blob-csi-driver/pkg/csi-common"
 )
 
@@ -57,38 +55,10 @@ func main() {
 		klog.Fatal("cannot start server:", err)
 	}
 
-	mountServer := server.NewMountServiceServer(getBlobfuseVersion())
+	mountServer := server.NewMountServiceServer()
 
 	klog.V(2).Info("Listening for connections on address: %v\n", listener.Addr())
 	if err = server.RunGRPCServer(mountServer, false, listener); err != nil {
 		klog.Fatalf("Error running grpc server. Error: %v", listener.Addr(), err)
 	}
 }
-
-func getOSInfo() (map[string]string, error) {
-	f := "/etc/lsb-release"
-	cfg, err := ini.Load(f)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to read %q", f)
-	}
-
-	OSInfo := make(map[string]string)
-	OSInfo["DISTRIB_ID"] = cfg.Section("").Key("DISTRIB_ID").String()
-	OSInfo["DISTRIB_RELEASE"] = cfg.Section("").Key("DISTRIB_RELEASE").String()
-
-	return OSInfo, nil
-}
-
-func getBlobfuseVersion() server.BlobfuseVersion {
-	OSInfo, err := getOSInfo()
-	if err != nil {
-		klog.Errorf("failed to get OS info: %v, default using blobfuse v1", err)
-		return server.BlobfuseV1
-	}
-	klog.Infof("OS info: %v", OSInfo)
-
-	if OSInfo["DISTRIB_ID"] == "Ubuntu" && OSInfo["DISTRIB_RELEASE"] >= "22.04" {
-		return server.BlobfuseV2
-	}
-	return server.BlobfuseV1
-}

pkg/blobfuse-proxy/server/server.go

@@ -27,6 +27,7 @@ import (
 	"google.golang.org/grpc"
 	"k8s.io/klog/v2"
 	mount_azure_blob "sigs.k8s.io/blob-csi-driver/pkg/blobfuse-proxy/pb"
+	"sigs.k8s.io/blob-csi-driver/pkg/util"
 )
 
 var (
@@ -46,10 +47,10 @@ type MountServer struct {
 }
 
 // NewMountServer returns a new Mountserver
-func NewMountServiceServer(ver BlobfuseVersion) *MountServer {
-	return &MountServer{
-		blobfuseVersion: ver,
-	}
+func NewMountServiceServer() *MountServer {
+	mountServer := &MountServer{}
+	mountServer.blobfuseVersion = getBlobfuseVersion()
+	return mountServer
 }
 
 // MountAzureBlob mounts an azure blob container to given location
@@ -101,3 +102,17 @@ func RunGRPCServer(
 	klog.V(2).Infof("Start GRPC server at %s, TLS = %t", listener.Addr().String(), enableTLS)
 	return grpcServer.Serve(listener)
 }
+
+func getBlobfuseVersion() BlobfuseVersion {
+	osinfo, err := util.GetOSInfo("/etc/lsb-release")
+	if err != nil {
+		klog.Warningf("failed to get OS info: %v, default using blobfuse v1", err)
+		return BlobfuseV1
+	}
+
+	if osinfo.Distro == "Ubuntu" && osinfo.Version >= "22.04" {
+		return BlobfuseV2
+	}
+
+	return BlobfuseV1
+}

pkg/util/util.go

@@ -21,6 +21,10 @@ import (
 	"os"
 	"strings"
 	"sync"
+
+	"github.com/go-ini/ini"
+	"github.com/pkg/errors"
+	"k8s.io/klog/v2"
 )
 
 const (
@@ -155,3 +159,27 @@ func ConvertTagsToMap(tags string) (map[string]string, error) {
 	}
 	return m, nil
 }
+
+type OsInfo struct {
+	Distro  string
+	Version string
+}
+
+const (
+	keyDistribID      = "DISTRIB_ID"
+	keyDistribRelease = "DISTRIB_RELEASE"
+)
+
+func GetOSInfo(f interface{}) (*OsInfo, error) {
+	cfg, err := ini.Load(f)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to read %q", f)
+	}
+
+	oi := &OsInfo{}
+	oi.Distro = cfg.Section("").Key(keyDistribID).String()
+	oi.Version = cfg.Section("").Key(keyDistribRelease).String()
+
+	klog.V(2).Infof("get OS info: %v", oi)
+	return oi, nil
+}

pkg/util/util_test.go

@@ -19,6 +19,7 @@ package util
 import (
 	"fmt"
 	"os"
+	"reflect"
 	"testing"
 	"time"
 
@@ -248,3 +249,47 @@ func TestConvertTagsToMap2(t *testing.T) {
 		assert.Equal(t, result, test.expected)
 	}
 }
+
+func TestGetOSInfo(t *testing.T) {
+	type args struct {
+		f interface{}
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *OsInfo
+		wantErr bool
+	}{
+		{
+			name: "file not exist",
+			args: args{
+				f: "/not-exist/not-exist",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "parse os info correctly",
+			args: args{
+				f: []byte("DISTRIB_ID=Ubuntu\nDISTRIB_RELEASE=22.04"),
+			},
+			want: &OsInfo{
+				Distro:  "Ubuntu",
+				Version: "22.04",
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetOSInfo(tt.args.f)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetOSInfo() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetOSInfo() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}