lib/crunchrun/singularity.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package crunchrun
   6
   7 import (
   8         "fmt"
   9         "io"
  10         "io/ioutil"
  11         "os"
  12         "os/exec"
  13         "sort"
  14         "strings"
  15         "syscall"
  16
  17         "git.arvados.org/arvados.git/sdk/go/arvados"
  18         "golang.org/x/net/context"
  19 )
  20
  21 type singularityExecutor struct {
  22         logf            func(string, ...interface{})
  23         spec            containerSpec
  24         tmpdir          string
  25         child           *exec.Cmd
  26         imageFilename   string // "sif" image
  27         containerClient *arvados.Client
  28         container       arvados.Container
  29         keepClient      IKeepClient
  30         keepMount       string
  31 }
  32
  33 func newSingularityExecutor(logf func(string, ...interface{})) (*singularityExecutor, error) {
  34         tmpdir, err := ioutil.TempDir("", "crunch-run-singularity-")
  35         if err != nil {
  36                 return nil, err
  37         }
  38         return &singularityExecutor{
  39                 logf:   logf,
  40                 tmpdir: tmpdir,
  41         }, nil
  42 }
  43
  44 func (e *singularityExecutor) getOrCreateProject(ownerUuid string, name string, create bool) (*arvados.Group, error) {
  45         var gp arvados.GroupList
  46         err := e.containerClient.RequestAndDecode(&gp,
  47                 arvados.EndpointGroupList.Method,
  48                 arvados.EndpointGroupList.Path,
  49                 nil, arvados.ListOptions{Filters: []arvados.Filter{
  50                         arvados.Filter{"owner_uuid", "=", ownerUuid},
  51                         arvados.Filter{"name", "=", name},
  52                         arvados.Filter{"group_class", "=", "project"},
  53                 },
  54                         Limit: 1})
  55         if err != nil {
  56                 return nil, err
  57         }
  58         if len(gp.Items) == 1 {
  59                 return &gp.Items[0], nil
  60         }
  61         if !create {
  62                 return nil, nil
  63         }
  64         var rgroup arvados.Group
  65         err = e.containerClient.RequestAndDecode(&rgroup,
  66                 arvados.EndpointGroupCreate.Method,
  67                 arvados.EndpointGroupCreate.Path,
  68                 nil, map[string]interface{}{
  69                         "group": map[string]string{
  70                                 "owner_uuid":  ownerUuid,
  71                                 "name":        name,
  72                                 "group_class": "project",
  73                         },
  74                 })
  75         if err != nil {
  76                 return nil, err
  77         }
  78         return &rgroup, nil
  79 }
  80
  81 func (e *singularityExecutor) ImageLoaded(imageId string) bool {
  82         // Check if docker image is cached in keep & if so set imageFilename
  83
  84         // Cache the image to keep
  85         cacheGroup, err := e.getOrCreateProject(e.container.RuntimeUserUUID, ".cache", false)
  86         if err != nil {
  87                 e.logf("error getting '.cache' project: %v", err)
  88                 return false
  89         }
  90         imageGroup, err := e.getOrCreateProject(cacheGroup.UUID, "auto-generated singularity images", false)
  91         if err != nil {
  92                 e.logf("error getting 'auto-generated singularity images' project: %s", err)
  93                 return false
  94         }
  95
  96         collectionName := fmt.Sprintf("singularity image for %v", imageId)
  97         var cl arvados.CollectionList
  98         err = e.containerClient.RequestAndDecode(&cl,
  99                 arvados.EndpointCollectionList.Method,
 100                 arvados.EndpointCollectionList.Path,
 101                 nil, arvados.ListOptions{Filters: []arvados.Filter{
 102                         arvados.Filter{"owner_uuid", "=", imageGroup.UUID},
 103                         arvados.Filter{"name", "=", collectionName},
 104                 },
 105                         Limit: 1})
 106         if err != nil {
 107                 e.logf("error getting collection '%v' project: %v", err)
 108                 return false
 109         }
 110         if len(cl.Items) == 0 {
 111                 e.logf("no cached image '%v' found", collectionName)
 112                 return false
 113         }
 114
 115         path := fmt.Sprintf("%s/by_id/%s/image.sif", e.keepMount, cl.Items[0].PortableDataHash)
 116         e.logf("Looking for %v", path)
 117         if _, err = os.Stat(path); os.IsNotExist(err) {
 118                 return false
 119         }
 120         e.imageFilename = path
 121
 122         return true
 123 }
 124
 125 // LoadImage will satisfy ContainerExecuter interface transforming
 126 // containerImage into a sif file for later use.
 127 func (e *singularityExecutor) LoadImage(imageTarballPath string) error {
 128         if e.imageFilename != "" {
 129                 e.logf("using singularity image %v", e.imageFilename)
 130
 131                 // was set by ImageLoaded
 132                 return nil
 133         }
 134
 135         e.logf("building singularity image")
 136         // "singularity build" does not accept a
 137         // docker-archive://... filename containing a ":" character,
 138         // as in "/path/to/sha256:abcd...1234.tar". Workaround: make a
 139         // symlink that doesn't have ":" chars.
 140         err := os.Symlink(imageTarballPath, e.tmpdir+"/image.tar")
 141         if err != nil {
 142                 return err
 143         }
 144         e.imageFilename = e.tmpdir + "/image.sif"
 145         build := exec.Command("singularity", "build", e.imageFilename, "docker-archive://"+e.tmpdir+"/image.tar")
 146         e.logf("%v", build.Args)
 147         out, err := build.CombinedOutput()
 148         // INFO:    Starting build...
 149         // Getting image source signatures
 150         // Copying blob ab15617702de done
 151         // Copying config 651e02b8a2 done
 152         // Writing manifest to image destination
 153         // Storing signatures
 154         // 2021/04/22 14:42:14  info unpack layer: sha256:21cbfd3a344c52b197b9fa36091e66d9cbe52232703ff78d44734f85abb7ccd3
 155         // INFO:    Creating SIF file...
 156         // INFO:    Build complete: arvados-jobs.latest.sif
 157         e.logf("%s", out)
 158         if err != nil {
 159                 return err
 160         }
 161
 162         // Cache the image to keep
 163         cacheGroup, err := e.getOrCreateProject(e.container.RuntimeUserUUID, ".cache", true)
 164         if err != nil {
 165                 e.logf("error getting '.cache' project: %v", err)
 166                 return nil
 167         }
 168         imageGroup, err := e.getOrCreateProject(cacheGroup.UUID, "auto-generated singularity images", true)
 169         if err != nil {
 170                 e.logf("error getting 'auto-generated singularity images' project: %v", err)
 171                 return nil
 172         }
 173
 174         parts := strings.Split(imageTarballPath, "/")
 175         imageId := parts[len(parts)-1]
 176         if strings.HasSuffix(imageId, ".tar") {
 177                 imageId = imageId[0 : len(imageId)-4]
 178         }
 179
 180         fs, err := (&arvados.Collection{ManifestText: ""}).FileSystem(e.containerClient, e.keepClient)
 181         if err != nil {
 182                 e.logf("error creating FileSystem: %s", err)
 183         }
 184
 185         dst, err := fs.OpenFile("image.sif", os.O_CREATE|os.O_WRONLY, 0666)
 186         if err != nil {
 187                 e.logf("error creating opening collection file for writing: %s", err)
 188         }
 189
 190         src, err := os.Open(e.imageFilename)
 191         if err != nil {
 192                 dst.Close()
 193                 return nil
 194         }
 195         defer src.Close()
 196         _, err = io.Copy(dst, src)
 197         if err != nil {
 198                 dst.Close()
 199                 return nil
 200         }
 201
 202         manifestText, err := fs.MarshalManifest(".")
 203         if err != nil {
 204                 e.logf("error creating manifest text: %s", err)
 205         }
 206
 207         var imageCollection arvados.Collection
 208         collectionName := fmt.Sprintf("singularity image for %s", imageId)
 209         err = e.containerClient.RequestAndDecode(&imageCollection,
 210                 arvados.EndpointCollectionCreate.Method,
 211                 arvados.EndpointCollectionCreate.Path,
 212                 nil, map[string]interface{}{
 213                         "collection": map[string]string{
 214                                 "owner_uuid":    imageGroup.UUID,
 215                                 "name":          collectionName,
 216                                 "manifest_text": manifestText,
 217                         },
 218                 })
 219         if err != nil {
 220                 e.logf("error creating '%v' collection: %s", collectionName, err)
 221         }
 222
 223         return nil
 224 }
 225
 226 func (e *singularityExecutor) Create(spec containerSpec) error {
 227         e.spec = spec
 228         return nil
 229 }
 230
 231 func (e *singularityExecutor) Start() error {
 232         args := []string{"singularity", "exec", "--containall", "--no-home", "--cleanenv", "--pwd", e.spec.WorkingDir}
 233         if !e.spec.EnableNetwork {
 234                 args = append(args, "--net", "--network=none")
 235         }
 236         readonlyflag := map[bool]string{
 237                 false: "rw",
 238                 true:  "ro",
 239         }
 240         var binds []string
 241         for path, _ := range e.spec.BindMounts {
 242                 binds = append(binds, path)
 243         }
 244         sort.Strings(binds)
 245         for _, path := range binds {
 246                 mount := e.spec.BindMounts[path]
 247                 args = append(args, "--bind", mount.HostPath+":"+path+":"+readonlyflag[mount.ReadOnly])
 248         }
 249
 250         // This is for singularity 3.5.2. There are some behaviors
 251         // that will change in singularity 3.6, please see:
 252         // https://sylabs.io/guides/3.7/user-guide/environment_and_metadata.html
 253         // https://sylabs.io/guides/3.5/user-guide/environment_and_metadata.html
 254         env := make([]string, 0, len(e.spec.Env))
 255         for k, v := range e.spec.Env {
 256                 if k == "HOME" {
 257                         // $HOME is a special case
 258                         args = append(args, "--home="+v)
 259                 } else {
 260                         env = append(env, "SINGULARITYENV_"+k+"="+v)
 261                 }
 262         }
 263
 264         args = append(args, e.imageFilename)
 265         args = append(args, e.spec.Command...)
 266
 267         path, err := exec.LookPath(args[0])
 268         if err != nil {
 269                 return err
 270         }
 271         child := &exec.Cmd{
 272                 Path:   path,
 273                 Args:   args,
 274                 Env:    env,
 275                 Stdin:  e.spec.Stdin,
 276                 Stdout: e.spec.Stdout,
 277                 Stderr: e.spec.Stderr,
 278         }
 279         err = child.Start()
 280         if err != nil {
 281                 return err
 282         }
 283         e.child = child
 284         return nil
 285 }
 286
 287 func (e *singularityExecutor) CgroupID() string {
 288         return ""
 289 }
 290
 291 func (e *singularityExecutor) Stop() error {
 292         if err := e.child.Process.Signal(syscall.Signal(0)); err != nil {
 293                 // process already exited
 294                 return nil
 295         }
 296         return e.child.Process.Signal(syscall.SIGKILL)
 297 }
 298
 299 func (e *singularityExecutor) Wait(context.Context) (int, error) {
 300         err := e.child.Wait()
 301         if err, ok := err.(*exec.ExitError); ok {
 302                 return err.ProcessState.ExitCode(), nil
 303         }
 304         if err != nil {
 305                 return 0, err
 306         }
 307         return e.child.ProcessState.ExitCode(), nil
 308 }
 309
 310 func (e *singularityExecutor) Close() {
 311         err := os.RemoveAll(e.tmpdir)
 312         if err != nil {
 313                 e.logf("error removing temp dir: %s", err)
 314         }
 315 }
 316
 317 func (e *singularityExecutor) SetArvadoClient(containerClient *arvados.Client, keepClient IKeepClient, container arvados.Container, keepMount string) {
 318         e.containerClient = containerClient
 319         e.container = container
 320         e.keepClient = keepClient
 321         e.keepMount = keepMount
 322 }