feat(vfs): add Linode (Akamai) object storage schema support

Signed-off-by: Moshe Vayner <moshe@vayner.me>

Author: moshevayner

util/pkg/vfs/context.go

@@ -185,6 +185,10 @@ func (c *VFSContext) BuildVfsPath(p string) (Path, error) {
 		return c.buildDOPath(p)
 	}
 
+	if strings.HasPrefix(p, "linode://") {
+		return c.buildLinodePath(p)
+	}
+
 	if strings.HasPrefix(p, "hos://") {
 		return c.buildHetznerPath(p)
 	}
@@ -360,6 +364,24 @@ func (c *VFSContext) buildDOPath(p string) (*S3Path, error) {
 	return s3path, nil
 }
 
+func (c *VFSContext) buildLinodePath(p string) (*S3Path, error) {
+	u, err := url.Parse(p)
+	if err != nil {
+		return nil, fmt.Errorf("invalid Linode object storage path: %q", p)
+	}
+	if u.Scheme != "linode" {
+		return nil, fmt.Errorf("invalid Linode object storage path: %q", p)
+	}
+
+	bucket := strings.TrimSuffix(u.Host, "/")
+	if bucket == "" {
+		return nil, fmt.Errorf("invalid Linode object storage path: %q", p)
+	}
+
+	s3path := newS3Path(c.s3Context, u.Scheme, bucket, u.Path, false)
+	return s3path, nil
+}
+
 func (c *VFSContext) buildHetznerPath(p string) (*S3Path, error) {
 	u, err := url.Parse(p)
 	if err != nil {

util/pkg/vfs/s3context.go

@@ -116,6 +116,11 @@ func (s *S3Context) getClient(ctx context.Context, region string, scheme string)
 				o.BaseEndpoint = aws.String(endpoint)
 				o.UsePathStyle = true
 				o.DisableLogOutputChecksumValidationSkipped = true
+				// Linode (Akamai) requires checksum-when-required behavior
+				if scheme == "linode" {
+					o.RequestChecksumCalculation = aws.RequestChecksumCalculationWhenRequired
+					o.ResponseChecksumValidation = aws.ResponseChecksumValidationWhenRequired
+				}
 			} else {
 				o.EndpointResolverV2 = &ResolverV2{}
 			}

util/pkg/vfs/s3fs.go

@@ -644,6 +644,10 @@ func (p *S3Path) IsBucketPublic(ctx context.Context) (bool, error) {
 }
 
 func (p *S3Path) IsPublic() (bool, error) {
+	if p.scheme == "linode" {
+		// Linode (Akamai) does not implement GetObjectAcl. In that case we conservatively treat the object as non-public and continue.
+		return false, nil
+	}
 	ctx := context.TODO()
 	client, err := p.client(ctx)
 	if err != nil {

util/pkg/vfs/s3fs_test.go

@@ -51,6 +51,9 @@ func Test_S3Path_Parse(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error parsing s3 path: %v", err)
 			}
+			if s3path.scheme != "s3" {
+				t.Fatalf("unexpected scheme for s3 path, got %q expected \"s3\": %v", s3path.scheme, s3path)
+			}
 			if s3path.bucket != g.ExpectedBucket {
 				t.Fatalf("unexpected s3 path: %v", s3path)
 			}
@@ -65,6 +68,81 @@ func Test_S3Path_Parse(t *testing.T) {
 	}
 }
 
+func Test_LinodePath_Parse(t *testing.T) {
+	grid := []struct {
+		Input          string
+		ExpectError    bool
+		ExpectedBucket string
+		ExpectedPath   string
+	}{
+		{
+			Input:          "linode://bucket",
+			ExpectedBucket: "bucket",
+			ExpectedPath:   "",
+		},
+		{
+			Input:          "linode://bucket/path",
+			ExpectedBucket: "bucket",
+			ExpectedPath:   "path",
+		},
+		{
+			Input:          "linode://bucket2/path/subpath",
+			ExpectedBucket: "bucket2",
+			ExpectedPath:   "path/subpath",
+		},
+		{
+			Input:       "linode:///bucket/path/subpath",
+			ExpectError: true,
+		},
+	}
+	for _, g := range grid {
+		s3path, err := Context.buildLinodePath(g.Input)
+		if !g.ExpectError {
+			if err != nil {
+				t.Fatalf("unexpected error parsing linode path: %v", err)
+			}
+			if s3path.scheme != "linode" {
+				t.Fatalf("expected scheme=\"linode\" for linode path, got %q: %v", s3path.scheme, s3path)
+			}
+			if s3path.bucket != g.ExpectedBucket {
+				t.Fatalf("unexpected linode path: %v", s3path)
+			}
+			if s3path.key != g.ExpectedPath {
+				t.Fatalf("unexpected linode path: %v", s3path)
+			}
+		} else {
+			if err == nil {
+				t.Fatalf("unexpected error parsing %q", g.Input)
+			}
+		}
+	}
+}
+
+func Test_NonLinodeObjectStoragePaths_HaveCorrectScheme(t *testing.T) {
+	grid := []struct {
+		name   string
+		input  string
+		scheme string
+		build  func(string) (*S3Path, error)
+	}{
+		{name: "do", input: "do://bucket/path", scheme: "do", build: Context.buildDOPath},
+		{name: "hos", input: "hos://bucket/path", scheme: "hos", build: Context.buildHetznerPath},
+		{name: "scw", input: "scw://bucket/path", scheme: "scw", build: Context.buildSCWPath},
+	}
+
+	for _, tc := range grid {
+		t.Run(tc.name, func(t *testing.T) {
+			s3path, err := tc.build(tc.input)
+			if err != nil {
+				t.Fatalf("unexpected error parsing %s path: %v", tc.name, err)
+			}
+			if s3path.scheme != tc.scheme {
+				t.Fatalf("unexpected scheme for %s path, got %q expected %q", tc.name, s3path.scheme, tc.scheme)
+			}
+		})
+	}
+}
+
 func TestGetHTTPsUrl(t *testing.T) {
 	grid := []struct {
 		Path        string