github.com/containers/libpod@v1.9.4-0.20220419124438-4284fd425507/cmd/podman/shared/intermediate_varlink.go (about)

     1  // +build varlink remoteclient
     2  
     3  package shared
     4  
     5  import (
     6  	"github.com/containers/libpod/cmd/podman/cliconfig"
     7  	"github.com/containers/libpod/pkg/rootless"
     8  	iopodman "github.com/containers/libpod/pkg/varlink"
     9  	"github.com/pkg/errors"
    10  )
    11  
    12  // StringSliceToPtr converts a genericcliresult value into a *[]string
    13  func StringSliceToPtr(g GenericCLIResult) *[]string {
    14  	if !g.IsSet() {
    15  		return nil
    16  	}
    17  	newT := g.Value().([]string)
    18  	return &newT
    19  }
    20  
    21  // StringToPtr converts a genericcliresult value into a *string
    22  func StringToPtr(g GenericCLIResult) *string {
    23  	if !g.IsSet() {
    24  		return nil
    25  	}
    26  	newT := g.Value().(string)
    27  	return &newT
    28  }
    29  
    30  // BoolToPtr converts a genericcliresult value into a *bool
    31  func BoolToPtr(g GenericCLIResult) *bool {
    32  	if !g.IsSet() {
    33  		return nil
    34  	}
    35  	newT := g.Value().(bool)
    36  	return &newT
    37  }
    38  
    39  // AnyIntToInt64Ptr converts a genericcliresult value into an *int64
    40  func AnyIntToInt64Ptr(g GenericCLIResult) *int64 {
    41  	if !g.IsSet() {
    42  		return nil
    43  	}
    44  	var newT int64
    45  	switch g.Value().(type) {
    46  	case int:
    47  		newT = int64(g.Value().(int))
    48  	case int64:
    49  		newT = g.Value().(int64)
    50  	case uint64:
    51  		newT = int64(g.Value().(uint64))
    52  	case uint:
    53  		newT = int64(g.Value().(uint))
    54  	default:
    55  		panic(errors.Errorf("invalid int type"))
    56  	}
    57  	return &newT
    58  }
    59  
    60  // Float64ToPtr converts a genericcliresult into a *float64
    61  func Float64ToPtr(g GenericCLIResult) *float64 {
    62  	if !g.IsSet() {
    63  		return nil
    64  	}
    65  	newT := g.Value().(float64)
    66  	return &newT
    67  }
    68  
    69  // MakeVarlink creates a varlink transportable struct from GenericCLIResults
    70  func (g GenericCLIResults) MakeVarlink() iopodman.Create {
    71  	v := iopodman.Create{
    72  		Args:                   g.InputArgs,
    73  		AddHost:                StringSliceToPtr(g.Find("add-host")),
    74  		Annotation:             StringSliceToPtr(g.Find("annotation")),
    75  		Attach:                 StringSliceToPtr(g.Find("attach")),
    76  		BlkioWeight:            StringToPtr(g.Find("blkio-weight")),
    77  		BlkioWeightDevice:      StringSliceToPtr(g.Find("blkio-weight-device")),
    78  		CapAdd:                 StringSliceToPtr(g.Find("cap-add")),
    79  		CapDrop:                StringSliceToPtr(g.Find("cap-drop")),
    80  		CgroupParent:           StringToPtr(g.Find("cgroup-parent")),
    81  		CidFile:                StringToPtr(g.Find("cidfile")),
    82  		ConmonPidfile:          StringToPtr(g.Find("conmon-pidfile")),
    83  		CpuPeriod:              AnyIntToInt64Ptr(g.Find("cpu-period")),
    84  		CpuQuota:               AnyIntToInt64Ptr(g.Find("cpu-quota")),
    85  		CpuRtPeriod:            AnyIntToInt64Ptr(g.Find("cpu-rt-period")),
    86  		CpuRtRuntime:           AnyIntToInt64Ptr(g.Find("cpu-rt-runtime")),
    87  		CpuShares:              AnyIntToInt64Ptr(g.Find("cpu-shares")),
    88  		Cpus:                   Float64ToPtr(g.Find("cpus")),
    89  		CpuSetCpus:             StringToPtr(g.Find("cpuset-cpus")),
    90  		CpuSetMems:             StringToPtr(g.Find("cpuset-mems")),
    91  		Detach:                 BoolToPtr(g.Find("detach")),
    92  		DetachKeys:             StringToPtr(g.Find("detach-keys")),
    93  		Device:                 StringSliceToPtr(g.Find("device")),
    94  		DeviceReadBps:          StringSliceToPtr(g.Find("device-read-bps")),
    95  		DeviceReadIops:         StringSliceToPtr(g.Find("device-read-iops")),
    96  		DeviceWriteBps:         StringSliceToPtr(g.Find("device-write-bps")),
    97  		DeviceWriteIops:        StringSliceToPtr(g.Find("device-write-iops")),
    98  		Dns:                    StringSliceToPtr(g.Find("dns")),
    99  		DnsOpt:                 StringSliceToPtr(g.Find("dns-opt")),
   100  		DnsSearch:              StringSliceToPtr(g.Find("dns-search")),
   101  		Entrypoint:             StringToPtr(g.Find("entrypoint")),
   102  		Env:                    StringSliceToPtr(g.Find("env")),
   103  		EnvFile:                StringSliceToPtr(g.Find("env-file")),
   104  		Expose:                 StringSliceToPtr(g.Find("expose")),
   105  		Gidmap:                 StringSliceToPtr(g.Find("gidmap")),
   106  		Groupadd:               StringSliceToPtr(g.Find("group-add")),
   107  		HealthcheckCommand:     StringToPtr(g.Find("healthcheck-command")),
   108  		HealthcheckInterval:    StringToPtr(g.Find("healthcheck-interval")),
   109  		HealthcheckRetries:     AnyIntToInt64Ptr(g.Find("healthcheck-retries")),
   110  		HealthcheckStartPeriod: StringToPtr(g.Find("healthcheck-start-period")),
   111  		HealthcheckTimeout:     StringToPtr(g.Find("healthcheck-timeout")),
   112  		Hostname:               StringToPtr(g.Find("hostname")),
   113  		ImageVolume:            StringToPtr(g.Find("image-volume")),
   114  		Init:                   BoolToPtr(g.Find("init")),
   115  		InitPath:               StringToPtr(g.Find("init-path")),
   116  		Interactive:            BoolToPtr(g.Find("interactive")),
   117  		Ip:                     StringToPtr(g.Find("ip")),
   118  		Ipc:                    StringToPtr(g.Find("ipc")),
   119  		KernelMemory:           StringToPtr(g.Find("kernel-memory")),
   120  		Label:                  StringSliceToPtr(g.Find("label")),
   121  		LabelFile:              StringSliceToPtr(g.Find("label-file")),
   122  		LogDriver:              StringToPtr(g.Find("log-driver")),
   123  		LogOpt:                 StringSliceToPtr(g.Find("log-opt")),
   124  		MacAddress:             StringToPtr(g.Find("mac-address")),
   125  		Memory:                 StringToPtr(g.Find("memory")),
   126  		MemoryReservation:      StringToPtr(g.Find("memory-reservation")),
   127  		MemorySwap:             StringToPtr(g.Find("memory-swap")),
   128  		MemorySwappiness:       AnyIntToInt64Ptr(g.Find("memory-swappiness")),
   129  		Name:                   StringToPtr(g.Find("name")),
   130  		Network:                StringToPtr(g.Find("network")),
   131  		OomKillDisable:         BoolToPtr(g.Find("oom-kill-disable")),
   132  		OomScoreAdj:            AnyIntToInt64Ptr(g.Find("oom-score-adj")),
   133  		OverrideOS:             StringToPtr(g.Find("override-os")),
   134  		OverrideArch:           StringToPtr(g.Find("override-arch")),
   135  		Pid:                    StringToPtr(g.Find("pid")),
   136  		PidsLimit:              AnyIntToInt64Ptr(g.Find("pids-limit")),
   137  		Pod:                    StringToPtr(g.Find("pod")),
   138  		Privileged:             BoolToPtr(g.Find("privileged")),
   139  		Publish:                StringSliceToPtr(g.Find("publish")),
   140  		PublishAll:             BoolToPtr(g.Find("publish-all")),
   141  		Pull:                   StringToPtr(g.Find("pull")),
   142  		Quiet:                  BoolToPtr(g.Find("quiet")),
   143  		Readonly:               BoolToPtr(g.Find("read-only")),
   144  		Readonlytmpfs:          BoolToPtr(g.Find("read-only-tmpfs")),
   145  		Restart:                StringToPtr(g.Find("restart")),
   146  		Rm:                     BoolToPtr(g.Find("rm")),
   147  		Rootfs:                 BoolToPtr(g.Find("rootfs")),
   148  		SecurityOpt:            StringSliceToPtr(g.Find("security-opt")),
   149  		ShmSize:                StringToPtr(g.Find("shm-size")),
   150  		StopSignal:             StringToPtr(g.Find("stop-signal")),
   151  		StopTimeout:            AnyIntToInt64Ptr(g.Find("stop-timeout")),
   152  		StorageOpt:             StringSliceToPtr(g.Find("storage-opt")),
   153  		Subuidname:             StringToPtr(g.Find("subuidname")),
   154  		Subgidname:             StringToPtr(g.Find("subgidname")),
   155  		Sysctl:                 StringSliceToPtr(g.Find("sysctl")),
   156  		Systemd:                StringToPtr(g.Find("systemd")),
   157  		Tmpfs:                  StringSliceToPtr(g.Find("tmpfs")),
   158  		Tty:                    BoolToPtr(g.Find("tty")),
   159  		Uidmap:                 StringSliceToPtr(g.Find("uidmap")),
   160  		Ulimit:                 StringSliceToPtr(g.Find("ulimit")),
   161  		User:                   StringToPtr(g.Find("user")),
   162  		Userns:                 StringToPtr(g.Find("userns")),
   163  		Uts:                    StringToPtr(g.Find("uts")),
   164  		Mount:                  StringSliceToPtr(g.Find("mount")),
   165  		Volume:                 StringSliceToPtr(g.Find("volume")),
   166  		VolumesFrom:            StringSliceToPtr(g.Find("volumes-from")),
   167  		WorkDir:                StringToPtr(g.Find("workdir")),
   168  	}
   169  
   170  	return v
   171  }
   172  
   173  func stringSliceFromVarlink(v *[]string, flagName string, defaultValue *[]string) CRStringSlice {
   174  	cr := CRStringSlice{}
   175  	if v == nil {
   176  		cr.Val = []string{}
   177  		if defaultValue != nil {
   178  			cr.Val = *defaultValue
   179  		}
   180  		cr.Changed = false
   181  	} else {
   182  		cr.Val = *v
   183  		cr.Changed = true
   184  	}
   185  	cr.Flag = flagName
   186  	return cr
   187  }
   188  
   189  func stringFromVarlink(v *string, flagName string, defaultValue *string) CRString {
   190  	cr := CRString{}
   191  	if v == nil {
   192  		cr.Val = ""
   193  		if defaultValue != nil {
   194  			cr.Val = *defaultValue
   195  		}
   196  		cr.Changed = false
   197  	} else {
   198  		cr.Val = *v
   199  		cr.Changed = true
   200  	}
   201  	cr.Flag = flagName
   202  	return cr
   203  }
   204  
   205  func boolFromVarlink(v *bool, flagName string, defaultValue bool) CRBool {
   206  	cr := CRBool{}
   207  	if v == nil {
   208  		// In case a cli bool default value is true
   209  		cr.Val = defaultValue
   210  		cr.Changed = false
   211  	} else {
   212  		cr.Val = *v
   213  		cr.Changed = true
   214  	}
   215  	cr.Flag = flagName
   216  	return cr
   217  }
   218  
   219  func uint64FromVarlink(v *int64, flagName string, defaultValue *uint64) CRUint64 {
   220  	cr := CRUint64{}
   221  	if v == nil {
   222  		cr.Val = 0
   223  		if defaultValue != nil {
   224  			cr.Val = *defaultValue
   225  		}
   226  		cr.Changed = false
   227  	} else {
   228  		cr.Val = uint64(*v)
   229  		cr.Changed = true
   230  	}
   231  	cr.Flag = flagName
   232  	return cr
   233  }
   234  
   235  func int64FromVarlink(v *int64, flagName string, defaultValue *int64) CRInt64 {
   236  	cr := CRInt64{}
   237  	if v == nil {
   238  		cr.Val = 0
   239  		if defaultValue != nil {
   240  			cr.Val = *defaultValue
   241  		}
   242  		cr.Changed = false
   243  	} else {
   244  		cr.Val = *v
   245  		cr.Changed = true
   246  	}
   247  	cr.Flag = flagName
   248  	return cr
   249  }
   250  
   251  func float64FromVarlink(v *float64, flagName string, defaultValue *float64) CRFloat64 {
   252  	cr := CRFloat64{}
   253  	if v == nil {
   254  		cr.Val = 0
   255  		if defaultValue != nil {
   256  			cr.Val = *defaultValue
   257  		}
   258  		cr.Changed = false
   259  	} else {
   260  		cr.Val = *v
   261  		cr.Changed = true
   262  	}
   263  	cr.Flag = flagName
   264  	return cr
   265  }
   266  
   267  func uintFromVarlink(v *int64, flagName string, defaultValue *uint) CRUint {
   268  	cr := CRUint{}
   269  	if v == nil {
   270  		cr.Val = 0
   271  		if defaultValue != nil {
   272  			cr.Val = *defaultValue
   273  		}
   274  		cr.Changed = false
   275  	} else {
   276  		cr.Val = uint(*v)
   277  		cr.Changed = true
   278  	}
   279  	cr.Flag = flagName
   280  	return cr
   281  }
   282  
   283  func stringArrayFromVarlink(v *[]string, flagName string, defaultValue *[]string) CRStringArray {
   284  	cr := CRStringArray{}
   285  	if v == nil {
   286  		cr.Val = []string{}
   287  		if defaultValue != nil {
   288  			cr.Val = *defaultValue
   289  		}
   290  		cr.Changed = false
   291  	} else {
   292  		cr.Val = *v
   293  		cr.Changed = true
   294  	}
   295  	cr.Flag = flagName
   296  	return cr
   297  }
   298  
   299  func intFromVarlink(v *int64, flagName string, defaultValue *int) CRInt {
   300  	cr := CRInt{}
   301  	if v == nil {
   302  		if defaultValue != nil {
   303  			cr.Val = *defaultValue
   304  		}
   305  		cr.Val = 0
   306  		cr.Changed = false
   307  	} else {
   308  		cr.Val = int(*v)
   309  		cr.Changed = true
   310  	}
   311  	cr.Flag = flagName
   312  	return cr
   313  }
   314  
   315  // VarlinkCreateToGeneric creates a GenericCLIResults from the varlink create
   316  // structure.
   317  func VarlinkCreateToGeneric(opts iopodman.Create) GenericCLIResults {
   318  
   319  	defaultContainerConfig := cliconfig.GetDefaultConfig()
   320  	// TODO | WARN
   321  	// We do not get a default network over varlink. Unlike the other default values for some cli
   322  	// elements, it seems it gets set to the default anyway.
   323  
   324  	var memSwapDefault int64 = -1
   325  	netModeDefault := "bridge"
   326  	systemdDefault := "true"
   327  	if rootless.IsRootless() {
   328  		netModeDefault = "slirp4netns"
   329  	}
   330  
   331  	m := make(map[string]GenericCLIResult)
   332  	m["add-host"] = stringSliceFromVarlink(opts.AddHost, "add-host", nil)
   333  	m["annotation"] = stringSliceFromVarlink(opts.Annotation, "annotation", nil)
   334  	m["attach"] = stringSliceFromVarlink(opts.Attach, "attach", nil)
   335  	m["blkio-weight"] = stringFromVarlink(opts.BlkioWeight, "blkio-weight", nil)
   336  	m["blkio-weight-device"] = stringSliceFromVarlink(opts.BlkioWeightDevice, "blkio-weight-device", nil)
   337  	m["cap-add"] = stringSliceFromVarlink(opts.CapAdd, "cap-add", nil)
   338  	m["cap-drop"] = stringSliceFromVarlink(opts.CapDrop, "cap-drop", nil)
   339  	m["cgroup-parent"] = stringFromVarlink(opts.CgroupParent, "cgroup-parent", nil)
   340  	m["cidfile"] = stringFromVarlink(opts.CidFile, "cidfile", nil)
   341  	m["conmon-pidfile"] = stringFromVarlink(opts.ConmonPidfile, "conmon-file", nil)
   342  	m["cpu-period"] = uint64FromVarlink(opts.CpuPeriod, "cpu-period", nil)
   343  	m["cpu-quota"] = int64FromVarlink(opts.CpuQuota, "quota", nil)
   344  	m["cpu-rt-period"] = uint64FromVarlink(opts.CpuRtPeriod, "cpu-rt-period", nil)
   345  	m["cpu-rt-runtime"] = int64FromVarlink(opts.CpuRtRuntime, "cpu-rt-quota", nil)
   346  	m["cpu-shares"] = uint64FromVarlink(opts.CpuShares, "cpu-shares", nil)
   347  	m["cpus"] = float64FromVarlink(opts.Cpus, "cpus", nil)
   348  	m["cpuset-cpus"] = stringFromVarlink(opts.CpuSetCpus, "cpuset-cpus", nil)
   349  	m["cpuset-mems"] = stringFromVarlink(opts.CpuSetMems, "cpuset-mems", nil)
   350  	m["detach"] = boolFromVarlink(opts.Detach, "detach", false)
   351  	m["detach-keys"] = stringFromVarlink(opts.DetachKeys, "detach-keys", nil)
   352  	m["device"] = stringSliceFromVarlink(opts.Device, "device", nil)
   353  	m["device-read-bps"] = stringSliceFromVarlink(opts.DeviceReadBps, "device-read-bps", nil)
   354  	m["device-read-iops"] = stringSliceFromVarlink(opts.DeviceReadIops, "device-read-iops", nil)
   355  	m["device-write-bps"] = stringSliceFromVarlink(opts.DeviceWriteBps, "write-device-bps", nil)
   356  	m["device-write-iops"] = stringSliceFromVarlink(opts.DeviceWriteIops, "write-device-iops", nil)
   357  	m["dns"] = stringSliceFromVarlink(opts.Dns, "dns", nil)
   358  	m["dns-opt"] = stringSliceFromVarlink(opts.DnsOpt, "dns-opt", nil)
   359  	m["dns-search"] = stringSliceFromVarlink(opts.DnsSearch, "dns-search", nil)
   360  	m["entrypoint"] = stringFromVarlink(opts.Entrypoint, "entrypoint", nil)
   361  	m["env"] = stringArrayFromVarlink(opts.Env, "env", nil)
   362  	m["env-file"] = stringSliceFromVarlink(opts.EnvFile, "env-file", nil)
   363  	m["expose"] = stringSliceFromVarlink(opts.Expose, "expose", nil)
   364  	m["gidmap"] = stringSliceFromVarlink(opts.Gidmap, "gidmap", nil)
   365  	m["group-add"] = stringSliceFromVarlink(opts.Groupadd, "group-add", nil)
   366  	m["healthcheck-command"] = stringFromVarlink(opts.HealthcheckCommand, "healthcheck-command", nil)
   367  	m["healthcheck-interval"] = stringFromVarlink(opts.HealthcheckInterval, "healthcheck-interval", &cliconfig.DefaultHealthCheckInterval)
   368  	m["healthcheck-retries"] = uintFromVarlink(opts.HealthcheckRetries, "healthcheck-retries", &cliconfig.DefaultHealthCheckRetries)
   369  	m["healthcheck-start-period"] = stringFromVarlink(opts.HealthcheckStartPeriod, "healthcheck-start-period", &cliconfig.DefaultHealthCheckStartPeriod)
   370  	m["healthcheck-timeout"] = stringFromVarlink(opts.HealthcheckTimeout, "healthcheck-timeout", &cliconfig.DefaultHealthCheckTimeout)
   371  	m["hostname"] = stringFromVarlink(opts.Hostname, "hostname", nil)
   372  	m["image-volume"] = stringFromVarlink(opts.ImageVolume, "image-volume", &cliconfig.DefaultImageVolume)
   373  	m["init"] = boolFromVarlink(opts.Init, "init", false)
   374  	m["init-path"] = stringFromVarlink(opts.InitPath, "init-path", nil)
   375  	m["interactive"] = boolFromVarlink(opts.Interactive, "interactive", false)
   376  	m["ip"] = stringFromVarlink(opts.Ip, "ip", nil)
   377  	m["ipc"] = stringFromVarlink(opts.Ipc, "ipc", nil)
   378  	m["kernel-memory"] = stringFromVarlink(opts.KernelMemory, "kernel-memory", nil)
   379  	m["label"] = stringArrayFromVarlink(opts.Label, "label", nil)
   380  	m["label-file"] = stringSliceFromVarlink(opts.LabelFile, "label-file", nil)
   381  	m["log-driver"] = stringFromVarlink(opts.LogDriver, "log-driver", nil)
   382  	m["log-opt"] = stringSliceFromVarlink(opts.LogOpt, "log-opt", nil)
   383  	m["mac-address"] = stringFromVarlink(opts.MacAddress, "mac-address", nil)
   384  	m["memory"] = stringFromVarlink(opts.Memory, "memory", nil)
   385  	m["memory-reservation"] = stringFromVarlink(opts.MemoryReservation, "memory-reservation", nil)
   386  	m["memory-swap"] = stringFromVarlink(opts.MemorySwap, "memory-swap", nil)
   387  	m["memory-swappiness"] = int64FromVarlink(opts.MemorySwappiness, "memory-swappiness", &memSwapDefault)
   388  	m["name"] = stringFromVarlink(opts.Name, "name", nil)
   389  	m["network"] = stringFromVarlink(opts.Network, "network", &netModeDefault)
   390  	m["no-hosts"] = boolFromVarlink(opts.NoHosts, "no-hosts", false)
   391  	m["oom-kill-disable"] = boolFromVarlink(opts.OomKillDisable, "oon-kill-disable", false)
   392  	m["oom-score-adj"] = intFromVarlink(opts.OomScoreAdj, "oom-score-adj", nil)
   393  	m["override-os"] = stringFromVarlink(opts.OverrideOS, "override-os", nil)
   394  	m["override-arch"] = stringFromVarlink(opts.OverrideArch, "override-arch", nil)
   395  	m["pid"] = stringFromVarlink(opts.Pid, "pid", nil)
   396  	m["pids-limit"] = int64FromVarlink(opts.PidsLimit, "pids-limit", nil)
   397  	m["pod"] = stringFromVarlink(opts.Pod, "pod", nil)
   398  	m["privileged"] = boolFromVarlink(opts.Privileged, "privileged", false)
   399  	m["publish"] = stringSliceFromVarlink(opts.Publish, "publish", nil)
   400  	m["publish-all"] = boolFromVarlink(opts.PublishAll, "publish-all", false)
   401  	m["pull"] = stringFromVarlink(opts.Pull, "missing", nil)
   402  	m["quiet"] = boolFromVarlink(opts.Quiet, "quiet", false)
   403  	m["read-only"] = boolFromVarlink(opts.Readonly, "read-only", false)
   404  	m["read-only-tmpfs"] = boolFromVarlink(opts.Readonlytmpfs, "read-only-tmpfs", true)
   405  	m["restart"] = stringFromVarlink(opts.Restart, "restart", nil)
   406  	m["rm"] = boolFromVarlink(opts.Rm, "rm", false)
   407  	m["rootfs"] = boolFromVarlink(opts.Rootfs, "rootfs", false)
   408  	m["security-opt"] = stringArrayFromVarlink(opts.SecurityOpt, "security-opt", nil)
   409  	m["shm-size"] = stringFromVarlink(opts.ShmSize, "shm-size", &defaultContainerConfig.Containers.ShmSize)
   410  	m["stop-signal"] = stringFromVarlink(opts.StopSignal, "stop-signal", nil)
   411  	m["stop-timeout"] = uintFromVarlink(opts.StopTimeout, "stop-timeout", nil)
   412  	m["storage-opt"] = stringSliceFromVarlink(opts.StorageOpt, "storage-opt", nil)
   413  	m["subgidname"] = stringFromVarlink(opts.Subgidname, "subgidname", nil)
   414  	m["subuidname"] = stringFromVarlink(opts.Subuidname, "subuidname", nil)
   415  	m["sysctl"] = stringSliceFromVarlink(opts.Sysctl, "sysctl", nil)
   416  	m["systemd"] = stringFromVarlink(opts.Systemd, "systemd", &systemdDefault)
   417  	m["tmpfs"] = stringSliceFromVarlink(opts.Tmpfs, "tmpfs", nil)
   418  	m["tty"] = boolFromVarlink(opts.Tty, "tty", false)
   419  	m["uidmap"] = stringSliceFromVarlink(opts.Uidmap, "uidmap", nil)
   420  	m["ulimit"] = stringSliceFromVarlink(opts.Ulimit, "ulimit", nil)
   421  	m["user"] = stringFromVarlink(opts.User, "user", nil)
   422  	m["userns"] = stringFromVarlink(opts.Userns, "userns", nil)
   423  	m["uts"] = stringFromVarlink(opts.Uts, "uts", nil)
   424  	m["mount"] = stringArrayFromVarlink(opts.Mount, "mount", nil)
   425  	m["volume"] = stringArrayFromVarlink(opts.Volume, "volume", nil)
   426  	m["volumes-from"] = stringSliceFromVarlink(opts.VolumesFrom, "volumes-from", nil)
   427  	m["workdir"] = stringFromVarlink(opts.WorkDir, "workdir", nil)
   428  
   429  	gcli := GenericCLIResults{m, opts.Args}
   430  	return gcli
   431  }
   432  
   433  // Find returns a flag from a GenericCLIResults by name
   434  func (g GenericCLIResults) Find(name string) GenericCLIResult {
   435  	result, ok := g.results[name]
   436  	if ok {
   437  		return result
   438  	}
   439  	panic(errors.Errorf("unable to find generic flag for varlink %s", name))
   440  }