Fetch remote topo

cmd/root.go

@@ -6,12 +6,14 @@ package cmd
 
 import (
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"time"
 
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/srl-labs/containerlab/utils"
 )
 
 var (
@@ -106,12 +108,27 @@ func getTopoFilePath(cmd *cobra.Command) error {
 		return nil
 	}
 
+	var err error
+	if utils.IsHttpUri(topo){
+		switch {
+		case utils.IsGitHubURL(topo):
+			err := utils.CheckSuffix(topo)
+			if err != nil {
+				return err
+			}
+			rawUrl := utils.GetRawURL(topo)
+			topo = utils.GetFileName(topo)
+			utils.DownloadFile(rawUrl, topo)
+		default:
+			return fmt.Errorf("unsupported git repositoy: %s", topo)
+		} 
+	}
+
 	// if topo or name flags have been provided, don't try to derive the topo file
 	if topo != "" || name != "" {
 		return nil
 	}
 
-	var err error
 
 	log.Debugf("trying to find topology files automatically")
 

utils/http.go

@@ -0,0 +1,64 @@
+package utils
+
+import (
+  "strings"
+  "errors"
+  "net/http"
+  "io"
+  "os"
+)
+
+
+func GetRawURL(url string) string {
+	if strings.Contains(url, "github.com") {
+		raw:=strings.Replace(url, "github.com", "raw.githubusercontent.com", 1)
+		return strings.Replace(raw, "/blob", "", 1)
+	}
+	return url
+}
+
+func IsGitHubURL(url string) bool {
+	return strings.Contains(url, "github")
+
+}
+
+func GetFileName(url string) string {
+	split := strings.Split(url, "/")
+	return split[len(split)-1]
+}
+
+// required global variable for tests, otherwise comparison operator fails as error instances were not equal
+var ErrInvalidSuffix = errors.New("valid URL passed in as topology file, but does not end with .yml or .yaml, endpoint must be an actual topology file")
+func CheckSuffix(url string) error {
+	// check if topo ends with either .yml or .yaml
+	if !strings.HasSuffix(url, ".yml") && !strings.HasSuffix(url, ".yaml") {
+		return ErrInvalidSuffix
+	}
+	return nil
+}
+
+func DownloadFile(url string, ouputFileName string) error {
+	// Get the data
+	resp, err := http.Get(url)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return errors.New("URL does not exist")
+	}
+	defer resp.Body.Close()
+
+	// Create the file
+	out, err := os.Create(ouputFileName)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Write the body to file
+	_, err = io.Copy(out, resp.Body)
+	if err != nil {
+		return err
+	}
+	return nil
+}

utils/http_test.go

@@ -0,0 +1,130 @@
+package utils
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+func TestIsGithubURL(t *testing.T) {
+	// tests that github urls are detected
+	var tests = []struct {
+		input    string
+		expected bool
+	}{
+		{"github.com", true},
+		{"github.com/containers/containerlab/blob/master/README.md", true},
+		{"google.com/containers", false},
+		{"google.com/containers/containerlab/blob/master/README.md", false},
+		{"gitlab.com/containers", false},
+		{"raw.githubusercontent.com/containers", true},
+	}
+	for _, test := range tests {
+		if output := IsGitHubURL(test.input); output != test.expected {
+			t.Error("Test Failed: {} inputted, {} expected, recieved: {}", test.input, test.expected, output)
+		}
+	}
+}
+
+func TestGetRawURL(t *testing.T) {
+	// tests that github urls are converted to raw urls evething else is left as is
+	var tests = []struct {
+		input    string
+		expected string
+	}{
+		{"github.com", "raw.githubusercontent.com"},
+		{"github.com/containers/containerlab/blob/master/README.md", "raw.githubusercontent.com/containers/containerlab/master/README.md"},
+		{"google.com/containers", "google.com/containers"},
+		{"google.com/containers/containerlab/blob/master/README.md", "google.com/containers/containerlab/blob/master/README.md"},
+		{"gitlab.com/containers", "gitlab.com/containers"},
+		{"raw.githubusercontent.com/containers", "raw.githubusercontent.com/containers"},
+	}
+	for _, test := range tests {
+		if output := GetRawURL(test.input); output != test.expected {
+			t.Error("Test Failed: {} inputted, {} expected, recieved: {}", test.input, test.expected, output)
+		}
+	}
+}
+
+func TestGetFileName(t *testing.T) {
+	// tests for valid file name
+	var tests = []struct {
+		input    string
+		expected string
+	}{
+		{"github.com", "github.com"},
+		{"github.com/containers/containerlab/blob/master/README.md", "README.md"},
+		{"google.com/containers", "containers"},
+		{"google.com/containers/containerlab/blob/master/README.md", "README.md"},
+		{"gitlab.com/containers", "containers"},
+		{"raw.githubusercontent.com/containers", "containers"},
+	}
+	for _, test := range tests {
+		if output := GetFileName(test.input); output != test.expected {
+			t.Error("Test Failed: {} inputted, {} expected, recieved: {}", test.input, test.expected, output)
+		}
+	}
+}
+
+func TestCheckSuffix(t *testing.T) {
+	// tests for valid suffix
+    var tests = []struct {
+        input    string
+        expected error
+    }{
+        {"github.com", ErrInvalidSuffix},
+        {"github.com/containers/containerlab/blob/master/README.md", ErrInvalidSuffix},
+        {"google.com/containers", ErrInvalidSuffix},
+        {"google.com/containers/containerlab/blob/master/README.md", ErrInvalidSuffix},
+        {"gitlab.com/containers", ErrInvalidSuffix},
+        {"raw.githubusercontent.com/containers", ErrInvalidSuffix},
+        {"github.com/containers/containerlab/blob/master/README.yml", nil},
+        {"github.com/containers/containerlab/blob/master/README.yaml", nil},
+    }
+    for _, test := range tests {
+        if output := CheckSuffix(test.input); output != test.expected {
+            t.Error("Test Failed: {} inputted, {} expected, recieved: {}", test.input, test.expected, output)
+        }
+    }
+}
+
+func TestDownloadFile(t *testing.T) {
+    tempDir := os.TempDir() 
+    // Create a mock HTTP server for testing
+    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        // Respond with a sample file content for testing
+        if r.URL.Path == "/valid" {
+            w.WriteHeader(http.StatusOK)
+            w.Write([]byte("This is a sample file content"))
+        } else {
+            w.WriteHeader(http.StatusNotFound)
+        }
+    }))
+    defer ts.Close()
+
+    // Test case 1: Download a file that exists
+    outputFileName := tempDir + "/downloaded_file.txt"
+    err := DownloadFile(ts.URL+"/valid", outputFileName)
+    if err != nil {
+        t.Fatalf("Expected no error, but got: %v", err)
+    }
+
+    // Check the content of the downloaded file
+    content, err := os.ReadFile(outputFileName)
+    if err != nil {
+        t.Fatalf("Failed to read the downloaded file: %v", err)
+    }
+    expectedContent := "This is a sample file content"
+    if string(content) != expectedContent {
+        t.Errorf("Expected content: %s, but got: %s", expectedContent, string(content))
+    }
+	os.Remove(outputFileName)
+    // Test case 2: Download a file that does not exist (simulate a non-200 response)
+    outputFileName = tempDir + "/nonexistent_file.txt"
+    err = DownloadFile(ts.URL+"/nonexistent", outputFileName)
+    expectedErrorMsg := "URL does not exist"
+    if err == nil || err.Error() != expectedErrorMsg {
+        t.Errorf("Expected error message '%s', but got: %v", expectedErrorMsg, err)
+    }
+}