AB#2104 Feat/azure logging (#198)

implementation for azure early boot logging
2025-09-28 14:59:32 -04:00 · 2022-06-10 13:18:30 +02:00 · 2022-06-10 13:18:30 +02:00 · 84552ca8f7
commit 84552ca8f7
parent 963c6f98e5
33 changed files with 526 additions and 212 deletions
--- a/internal/azureshared/metadata.go
+++ b/internal/azureshared/metadata.go
@ -0,0 +1,61 @@
+package azureshared
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var (
+	azureVMProviderIDRegexp   = regexp.MustCompile(`^azure:///subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.Compute/virtualMachines/([^/]+)$`)
+	azureVMSSProviderIDRegexp = regexp.MustCompile(`^azure:///subscriptions/([^/]+)/resourceGroups/([^/]+)/providers/Microsoft.Compute/virtualMachineScaleSets/([^/]+)/virtualMachines/([^/]+)$`)
+)
+
+// BasicsFromProviderID extracts subscriptionID and resourceGroup from both types of valid azure providerID.
+func BasicsFromProviderID(providerID string) (subscriptionID, resourceGroup string, err error) {
+	subscriptionID, resourceGroup, _, err = VMInformationFromProviderID(providerID)
+	if err == nil {
+		return subscriptionID, resourceGroup, nil
+	}
+	subscriptionID, resourceGroup, _, _, err = ScaleSetInformationFromProviderID(providerID)
+	if err == nil {
+		return subscriptionID, resourceGroup, nil
+	}
+	return "", "", fmt.Errorf("providerID %v is malformatted", providerID)
+}
+
+// UIDFromProviderID extracts our own generated unique ID, which is the
+// suffix at the resource group, e.g., resource-group-J18dB
+// J18dB is the UID.
+func UIDFromProviderID(providerID string) (string, error) {
+	_, resourceGroup, err := BasicsFromProviderID(providerID)
+	if err != nil {
+		return "", err
+	}
+
+	parts := strings.Split(resourceGroup, "-")
+	return parts[len(parts)-1], nil
+}
+
+// VMInformationFromProviderID splits a provider's id belonging to a single azure instance into core components.
+// A providerID  for individual VMs is build after the following schema:
+// - 'azure:///subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Compute/virtualMachines/<instance-name>'
+func VMInformationFromProviderID(providerID string) (subscriptionID, resourceGroup, instanceName string, err error) {
+	matches := azureVMProviderIDRegexp.FindStringSubmatch(providerID)
+	if len(matches) != 4 {
+		return "", "", "", errors.New("error splitting providerID")
+	}
+	return matches[1], matches[2], matches[3], nil
+}
+
+// ScaleSetInformationFromProviderID splits a provider's id belonging to an azure scaleset into core components.
+// A providerID for scale set VMs is build after the following schema:
+// - 'azure:///subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Compute/virtualMachineScaleSets/<scale-set-name>/virtualMachines/<instance-id>'
+func ScaleSetInformationFromProviderID(providerID string) (subscriptionID, resourceGroup, scaleSet, instanceID string, err error) {
+	matches := azureVMSSProviderIDRegexp.FindStringSubmatch(providerID)
+	if len(matches) != 5 {
+		return "", "", "", "", errors.New("error splitting providerID")
+	}
+	return matches[1], matches[2], matches[3], matches[4], nil
+}
--- a/internal/azureshared/metadata_test.go
+++ b/internal/azureshared/metadata_test.go
@ -0,0 +1,177 @@
+package azureshared
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBasicsFromProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		providerID         string
+		wantErr            bool
+		wantSubscriptionID string
+		wantResourceGroup  string
+	}{
+		"providerID for individual instance works": {
+			providerID:         "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachines/instance-name",
+			wantSubscriptionID: "subscription-id",
+			wantResourceGroup:  "resource-group",
+		},
+		"providerID for scale set instance works": {
+			providerID:         "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachineScaleSets/scale-set-name/virtualMachines/instance-id",
+			wantSubscriptionID: "subscription-id",
+			wantResourceGroup:  "resource-group",
+		},
+		"providerID is malformed": {
+			providerID: "malformed-provider-id",
+			wantErr:    true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+			require := require.New(t)
+
+			subscriptionID, resourceGroup, err := BasicsFromProviderID(tc.providerID)
+
+			if tc.wantErr {
+				assert.Error(err)
+				return
+			}
+			require.NoError(err)
+			assert.Equal(tc.wantSubscriptionID, subscriptionID)
+			assert.Equal(tc.wantResourceGroup, resourceGroup)
+		})
+	}
+}
+
+func TestUIDFromProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		providerID string
+		wantUID    string
+		wantErr    bool
+	}{
+		"UID from virtual machine works": {
+			providerID: "azure:///subscriptions/subscription-id/resourceGroups/resource-group-ABC123/providers/Microsoft.Compute/virtualMachines/instance-name",
+			wantUID:    "ABC123",
+		},
+		"providerID is malformed": {
+			providerID: "malformed-provider-id",
+			wantErr:    true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+			require := require.New(t)
+
+			uid, err := UIDFromProviderID(tc.providerID)
+
+			if tc.wantErr {
+				assert.Error(err)
+				return
+			}
+			require.NoError(err)
+			assert.Equal(tc.wantUID, uid)
+		})
+	}
+}
+
+func TestVMInformationFromProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		providerID         string
+		wantSubscriptionID string
+		wantResourceGroup  string
+		wantInstanceName   string
+		wantErr            bool
+	}{
+		"simple id": {
+			providerID:         "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachines/instance-id",
+			wantSubscriptionID: "subscription-id",
+			wantResourceGroup:  "resource-group",
+			wantInstanceName:   "instance-id",
+		},
+		"missing instance": {
+			providerID: "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachines",
+			wantErr:    true,
+		},
+		"providerID for scale set instance must fail": {
+			providerID: "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachineScaleSets/scale-set-name/virtualMachines/instance-id",
+			wantErr:    true,
+		},
+		"wrong provider": {
+			providerID: "gcp:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachines/instance-id",
+			wantErr:    true,
+		},
+		"providerID is malformed": {
+			providerID: "malformed-provider-id",
+			wantErr:    true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			subscriptionID, resourceGroup, instanceName, err := VMInformationFromProviderID(tc.providerID)
+
+			if tc.wantErr {
+				assert.Error(err)
+				return
+			}
+			assert.NoError(err)
+			assert.Equal(tc.wantSubscriptionID, subscriptionID)
+			assert.Equal(tc.wantResourceGroup, resourceGroup)
+			assert.Equal(tc.wantInstanceName, instanceName)
+		})
+	}
+}
+
+func TestScaleSetInformationFromProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		providerID         string
+		wantSubscriptionID string
+		wantResourceGroup  string
+		wantScaleSet       string
+		wantInstanceID     string
+		wantErr            bool
+	}{
+		"providerID for scale set instance works": {
+			providerID:         "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachineScaleSets/scale-set-name/virtualMachines/instance-id",
+			wantSubscriptionID: "subscription-id",
+			wantResourceGroup:  "resource-group",
+			wantScaleSet:       "scale-set-name",
+			wantInstanceID:     "instance-id",
+		},
+		"providerID for individual instance must fail": {
+			providerID: "azure:///subscriptions/subscription-id/resourceGroups/resource-group/providers/Microsoft.Compute/virtualMachines/instance-name",
+			wantErr:    true,
+		},
+		"providerID is malformed": {
+			providerID: "malformed-provider-id",
+			wantErr:    true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			subscriptionID, resourceGroup, scaleSet, instanceName, err := ScaleSetInformationFromProviderID(tc.providerID)
+
+			if tc.wantErr {
+				assert.Error(err)
+				return
+			}
+			assert.NoError(err)
+			assert.Equal(tc.wantSubscriptionID, subscriptionID)
+			assert.Equal(tc.wantResourceGroup, resourceGroup)
+			assert.Equal(tc.wantScaleSet, scaleSet)
+			assert.Equal(tc.wantInstanceID, instanceName)
+		})
+	}
+}
--- a/internal/gcpshared/metadata.go
+++ b/internal/gcpshared/metadata.go
@ -0,0 +1,24 @@
+package gcpshared
+
+import (
+	"fmt"
+	"regexp"
+)
+
+var providerIDRegex = regexp.MustCompile(`^gce://([^/]+)/([^/]+)/([^/]+)$`)
+
+// SplitProviderID splits a provider's id into core components.
+// A providerID is build after the schema 'gce://<project-id>/<zone>/<instance-name>'
+func SplitProviderID(providerID string) (project, zone, instance string, err error) {
+	matches := providerIDRegex.FindStringSubmatch(providerID)
+	if len(matches) != 4 {
+		return "", "", "", fmt.Errorf("error splitting providerID: %v", providerID)
+	}
+	return matches[1], matches[2], matches[3], nil
+}
+
+// JoinProviderID builds a k8s provider ID for GCP instances.
+// A providerID is build after the schema 'gce://<project-id>/<zone>/<instance-name>'
+func JoinProviderID(project, zone, instanceName string) string {
+	return fmt.Sprintf("gce://%v/%v/%v", project, zone, instanceName)
+}
--- a/internal/gcpshared/metadata_test.go
+++ b/internal/gcpshared/metadata_test.go
@ -0,0 +1,75 @@
+package gcpshared
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSplitProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		providerID    string
+		wantProjectID string
+		wantZone      string
+		wantInstance  string
+		wantErr       bool
+	}{
+		"simple id": {
+			providerID:    "gce://someProject/someZone/someInstance",
+			wantProjectID: "someProject",
+			wantZone:      "someZone",
+			wantInstance:  "someInstance",
+		},
+		"incomplete id": {
+			providerID: "gce://someProject/someZone",
+			wantErr:    true,
+		},
+		"wrong provider": {
+			providerID: "azure://someProject/someZone/someInstance",
+			wantErr:    true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			projectID, zone, instance, err := SplitProviderID(tc.providerID)
+
+			if tc.wantErr {
+				assert.Error(err)
+				return
+			}
+			assert.NoError(err)
+			assert.Equal(tc.wantProjectID, projectID)
+			assert.Equal(tc.wantZone, zone)
+			assert.Equal(tc.wantInstance, instance)
+		})
+	}
+}
+
+func TestJoinProviderID(t *testing.T) {
+	testCases := map[string]struct {
+		projectID      string
+		zone           string
+		instance       string
+		wantProviderID string
+	}{
+		"simple id": {
+			projectID:      "someProject",
+			zone:           "someZone",
+			instance:       "someInstance",
+			wantProviderID: "gce://someProject/someZone/someInstance",
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			providerID := JoinProviderID(tc.projectID, tc.zone, tc.instance)
+
+			assert.Equal(tc.wantProviderID, providerID)
+		})
+	}
+}