github.com/containerd/Containerd@v1.4.13/runtime/v1/linux/bundle_test.go (about)

     1  //go:build linux
     2  // +build linux
     3  
     4  /*
     5     Copyright The containerd Authors.
     6  
     7     Licensed under the Apache License, Version 2.0 (the "License");
     8     you may not use this file except in compliance with the License.
     9     You may obtain a copy of the License at
    10  
    11         http://www.apache.org/licenses/LICENSE-2.0
    12  
    13     Unless required by applicable law or agreed to in writing, software
    14     distributed under the License is distributed on an "AS IS" BASIS,
    15     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    16     See the License for the specific language governing permissions and
    17     limitations under the License.
    18  */
    19  
    20  package linux
    21  
    22  import (
    23  	"encoding/json"
    24  	"fmt"
    25  	"io/ioutil"
    26  	"os"
    27  	"path/filepath"
    28  	"strconv"
    29  	"syscall"
    30  	"testing"
    31  
    32  	"github.com/containerd/containerd/oci"
    33  	"github.com/containerd/continuity/testutil"
    34  	"github.com/opencontainers/runtime-spec/specs-go"
    35  )
    36  
    37  func TestNewBundle(t *testing.T) {
    38  	testutil.RequiresRoot(t)
    39  	tests := []struct {
    40  		userns bool
    41  	}{{
    42  		userns: false,
    43  	}, {
    44  		userns: true,
    45  	}}
    46  	const usernsGID = 4200
    47  
    48  	for i, tc := range tests {
    49  		t.Run(strconv.Itoa(i), func(t *testing.T) {
    50  			dir, err := ioutil.TempDir("", "test-new-bundle")
    51  			if err != nil {
    52  				t.Fatal("failed to create test directory", err)
    53  			}
    54  			defer os.RemoveAll(dir)
    55  			work := filepath.Join(dir, "work")
    56  			state := filepath.Join(dir, "state")
    57  			id := fmt.Sprintf("new-bundle-%d", i)
    58  			spec := oci.Spec{}
    59  			if tc.userns {
    60  				spec.Linux = &specs.Linux{
    61  					GIDMappings: []specs.LinuxIDMapping{{ContainerID: 0, HostID: usernsGID}},
    62  				}
    63  			}
    64  			specBytes, err := json.Marshal(&spec)
    65  			if err != nil {
    66  				t.Fatal("failed to marshal spec", err)
    67  			}
    68  
    69  			b, err := newBundle(id, work, state, specBytes)
    70  			if err != nil {
    71  				t.Fatal("newBundle should succeed", err)
    72  			}
    73  			if b == nil {
    74  				t.Fatal("bundle should not be nil")
    75  			}
    76  
    77  			fi, err := os.Stat(b.path)
    78  			if err != nil {
    79  				t.Error("should be able to stat bundle path", err)
    80  			}
    81  			if tc.userns {
    82  				if fi.Mode() != os.ModeDir|0710 {
    83  					t.Error("bundle path should be a directory with perm 0710")
    84  				}
    85  			} else {
    86  				if fi.Mode() != os.ModeDir|0700 {
    87  					t.Error("bundle path should be a directory with perm 0700")
    88  				}
    89  			}
    90  			stat, ok := fi.Sys().(*syscall.Stat_t)
    91  			if !ok {
    92  				t.Fatal("should assert to *syscall.Stat_t")
    93  			}
    94  			expectedGID := uint32(0)
    95  			if tc.userns {
    96  				expectedGID = usernsGID
    97  			}
    98  			if stat.Gid != expectedGID {
    99  				t.Error("gid should match", expectedGID, stat.Gid)
   100  			}
   101  		})
   102  	}
   103  }
   104  
   105  func TestRemappedGID(t *testing.T) {
   106  	tests := []struct {
   107  		spec oci.Spec
   108  		gid  uint32
   109  	}{{
   110  		// empty spec
   111  		spec: oci.Spec{},
   112  		gid:  0,
   113  	}, {
   114  		// empty Linux section
   115  		spec: oci.Spec{
   116  			Linux: &specs.Linux{},
   117  		},
   118  		gid: 0,
   119  	}, {
   120  		// empty ID mappings
   121  		spec: oci.Spec{
   122  			Linux: &specs.Linux{
   123  				GIDMappings: make([]specs.LinuxIDMapping, 0),
   124  			},
   125  		},
   126  		gid: 0,
   127  	}, {
   128  		// valid ID mapping
   129  		spec: oci.Spec{
   130  			Linux: &specs.Linux{
   131  				GIDMappings: []specs.LinuxIDMapping{{
   132  					ContainerID: 0,
   133  					HostID:      1000,
   134  				}},
   135  			},
   136  		},
   137  		gid: 1000,
   138  	}, {
   139  		// missing ID mapping
   140  		spec: oci.Spec{
   141  			Linux: &specs.Linux{
   142  				GIDMappings: []specs.LinuxIDMapping{{
   143  					ContainerID: 100,
   144  					HostID:      1000,
   145  				}},
   146  			},
   147  		},
   148  		gid: 0,
   149  	}}
   150  
   151  	for i, tc := range tests {
   152  		t.Run(strconv.Itoa(i), func(t *testing.T) {
   153  			s, err := json.Marshal(tc.spec)
   154  			if err != nil {
   155  				t.Fatal("failed to marshal spec", err)
   156  			}
   157  			gid, err := remappedGID(s)
   158  			if err != nil {
   159  				t.Error("should unmarshal successfully", err)
   160  			}
   161  			if gid != tc.gid {
   162  				t.Error("expected GID to match", tc.gid, gid)
   163  			}
   164  		})
   165  	}
   166  }