_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14400 | AddProcessRlimits | train | func (g *Generator) AddProcessRlimits(rType string, rHard uint64, rSoft uint64) {
g.initConfigProcess()
for i, rlimit := range g.Config.Process.Rlimits {
if rlimit.Type == rType {
g.Config.Process.Rlimits[i].Hard = rHard
g.Config.Process.Rlimits[i].Soft = rSoft
return
}
}
newRlimit := rspec.POSIXRlimit{
Type: rType,
Hard: rHard,
Soft: rSoft,
}
g.Config.Process.Rlimits = append(g.Config.Process.Rlimits, newRlimit)
} | go | {
"resource": ""
} |
q14401 | RemoveProcessRlimits | train | func (g *Generator) RemoveProcessRlimits(rType string) {
if g.Config == nil || g.Config.Process == nil {
return
}
for i, rlimit := range g.Config.Process.Rlimits {
if rlimit.Type == rType {
g.Config.Process.Rlimits = append(g.Config.Process.Rlimits[:i], g.Config.Process.Rlimits[i+1:]...)
return
}
}
} | go | {
"resource": ""
} |
q14402 | ClearProcessRlimits | train | func (g *Generator) ClearProcessRlimits() {
if g.Config == nil || g.Config.Process == nil {
return
}
g.Config.Process.Rlimits = []rspec.POSIXRlimit{}
} | go | {
"resource": ""
} |
q14403 | ClearProcessAdditionalGids | train | func (g *Generator) ClearProcessAdditionalGids() {
if g.Config == nil || g.Config.Process == nil {
return
}
g.Config.Process.User.AdditionalGids = []uint32{}
} | go | {
"resource": ""
} |
q14404 | AddProcessAdditionalGid | train | func (g *Generator) AddProcessAdditionalGid(gid uint32) {
g.initConfigProcess()
for _, group := range g.Config.Process.User.AdditionalGids {
if group == gid {
return
}
}
g.Config.Process.User.AdditionalGids = append(g.Config.Process.User.AdditionalGids, gid)
} | go | {
"resource": ""
} |
q14405 | SetProcessSelinuxLabel | train | func (g *Generator) SetProcessSelinuxLabel(label string) {
g.initConfigProcess()
g.Config.Process.SelinuxLabel = label
} | go | {
"resource": ""
} |
q14406 | SetLinuxCgroupsPath | train | func (g *Generator) SetLinuxCgroupsPath(path string) {
g.initConfigLinux()
g.Config.Linux.CgroupsPath = path
} | go | {
"resource": ""
} |
q14407 | SetLinuxIntelRdtL3CacheSchema | train | func (g *Generator) SetLinuxIntelRdtL3CacheSchema(schema string) {
g.initConfigLinuxIntelRdt()
g.Config.Linux.IntelRdt.L3CacheSchema = schema
} | go | {
"resource": ""
} |
q14408 | SetLinuxMountLabel | train | func (g *Generator) SetLinuxMountLabel(label string) {
g.initConfigLinux()
g.Config.Linux.MountLabel = label
} | go | {
"resource": ""
} |
q14409 | SetProcessOOMScoreAdj | train | func (g *Generator) SetProcessOOMScoreAdj(adj int) {
g.initConfigProcess()
g.Config.Process.OOMScoreAdj = &adj
} | go | {
"resource": ""
} |
q14410 | SetLinuxResourcesBlockIOLeafWeight | train | func (g *Generator) SetLinuxResourcesBlockIOLeafWeight(weight uint16) {
g.initConfigLinuxResourcesBlockIO()
g.Config.Linux.Resources.BlockIO.LeafWeight = &weight
} | go | {
"resource": ""
} |
q14411 | SetLinuxResourcesBlockIOWeight | train | func (g *Generator) SetLinuxResourcesBlockIOWeight(weight uint16) {
g.initConfigLinuxResourcesBlockIO()
g.Config.Linux.Resources.BlockIO.Weight = &weight
} | go | {
"resource": ""
} |
q14412 | AddLinuxResourcesBlockIOWeightDevice | train | func (g *Generator) AddLinuxResourcesBlockIOWeightDevice(major int64, minor int64, weight uint16) {
g.initConfigLinuxResourcesBlockIO()
for i, weightDevice := range g.Config.Linux.Resources.BlockIO.WeightDevice {
if weightDevice.Major == major && weightDevice.Minor == minor {
g.Config.Linux.Resources.BlockIO.WeightDevice[i].Weight = &weight
return
}
}
weightDevice := new(rspec.LinuxWeightDevice)
weightDevice.Major = major
weightDevice.Minor = minor
weightDevice.Weight = &weight
g.Config.Linux.Resources.BlockIO.WeightDevice = append(g.Config.Linux.Resources.BlockIO.WeightDevice, *weightDevice)
} | go | {
"resource": ""
} |
q14413 | DropLinuxResourcesBlockIOWeightDevice | train | func (g *Generator) DropLinuxResourcesBlockIOWeightDevice(major int64, minor int64) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.BlockIO == nil {
return
}
for i, weightDevice := range g.Config.Linux.Resources.BlockIO.WeightDevice {
if weightDevice.Major == major && weightDevice.Minor == minor {
if weightDevice.LeafWeight != nil {
newWeightDevice := new(rspec.LinuxWeightDevice)
newWeightDevice.Major = major
newWeightDevice.Minor = minor
newWeightDevice.LeafWeight = weightDevice.LeafWeight
g.Config.Linux.Resources.BlockIO.WeightDevice[i] = *newWeightDevice
} else {
g.Config.Linux.Resources.BlockIO.WeightDevice = append(g.Config.Linux.Resources.BlockIO.WeightDevice[:i], g.Config.Linux.Resources.BlockIO.WeightDevice[i+1:]...)
}
return
}
}
} | go | {
"resource": ""
} |
q14414 | AddLinuxResourcesBlockIOThrottleReadBpsDevice | train | func (g *Generator) AddLinuxResourcesBlockIOThrottleReadBpsDevice(major int64, minor int64, rate uint64) {
g.initConfigLinuxResourcesBlockIO()
throttleDevices := addOrReplaceBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleReadBpsDevice, major, minor, rate)
g.Config.Linux.Resources.BlockIO.ThrottleReadBpsDevice = throttleDevices
} | go | {
"resource": ""
} |
q14415 | DropLinuxResourcesBlockIOThrottleReadBpsDevice | train | func (g *Generator) DropLinuxResourcesBlockIOThrottleReadBpsDevice(major int64, minor int64) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.BlockIO == nil {
return
}
throttleDevices := dropBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleReadBpsDevice, major, minor)
g.Config.Linux.Resources.BlockIO.ThrottleReadBpsDevice = throttleDevices
} | go | {
"resource": ""
} |
q14416 | AddLinuxResourcesBlockIOThrottleReadIOPSDevice | train | func (g *Generator) AddLinuxResourcesBlockIOThrottleReadIOPSDevice(major int64, minor int64, rate uint64) {
g.initConfigLinuxResourcesBlockIO()
throttleDevices := addOrReplaceBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleReadIOPSDevice, major, minor, rate)
g.Config.Linux.Resources.BlockIO.ThrottleReadIOPSDevice = throttleDevices
} | go | {
"resource": ""
} |
q14417 | DropLinuxResourcesBlockIOThrottleReadIOPSDevice | train | func (g *Generator) DropLinuxResourcesBlockIOThrottleReadIOPSDevice(major int64, minor int64) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.BlockIO == nil {
return
}
throttleDevices := dropBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleReadIOPSDevice, major, minor)
g.Config.Linux.Resources.BlockIO.ThrottleReadIOPSDevice = throttleDevices
} | go | {
"resource": ""
} |
q14418 | AddLinuxResourcesBlockIOThrottleWriteBpsDevice | train | func (g *Generator) AddLinuxResourcesBlockIOThrottleWriteBpsDevice(major int64, minor int64, rate uint64) {
g.initConfigLinuxResourcesBlockIO()
throttleDevices := addOrReplaceBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleWriteBpsDevice, major, minor, rate)
g.Config.Linux.Resources.BlockIO.ThrottleWriteBpsDevice = throttleDevices
} | go | {
"resource": ""
} |
q14419 | DropLinuxResourcesBlockIOThrottleWriteBpsDevice | train | func (g *Generator) DropLinuxResourcesBlockIOThrottleWriteBpsDevice(major int64, minor int64) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.BlockIO == nil {
return
}
throttleDevices := dropBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleWriteBpsDevice, major, minor)
g.Config.Linux.Resources.BlockIO.ThrottleWriteBpsDevice = throttleDevices
} | go | {
"resource": ""
} |
q14420 | AddLinuxResourcesBlockIOThrottleWriteIOPSDevice | train | func (g *Generator) AddLinuxResourcesBlockIOThrottleWriteIOPSDevice(major int64, minor int64, rate uint64) {
g.initConfigLinuxResourcesBlockIO()
throttleDevices := addOrReplaceBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleWriteIOPSDevice, major, minor, rate)
g.Config.Linux.Resources.BlockIO.ThrottleWriteIOPSDevice = throttleDevices
} | go | {
"resource": ""
} |
q14421 | DropLinuxResourcesBlockIOThrottleWriteIOPSDevice | train | func (g *Generator) DropLinuxResourcesBlockIOThrottleWriteIOPSDevice(major int64, minor int64) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.BlockIO == nil {
return
}
throttleDevices := dropBlockIOThrottleDevice(g.Config.Linux.Resources.BlockIO.ThrottleWriteIOPSDevice, major, minor)
g.Config.Linux.Resources.BlockIO.ThrottleWriteIOPSDevice = throttleDevices
} | go | {
"resource": ""
} |
q14422 | SetLinuxResourcesCPUShares | train | func (g *Generator) SetLinuxResourcesCPUShares(shares uint64) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.Shares = &shares
} | go | {
"resource": ""
} |
q14423 | SetLinuxResourcesCPUQuota | train | func (g *Generator) SetLinuxResourcesCPUQuota(quota int64) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.Quota = "a
} | go | {
"resource": ""
} |
q14424 | SetLinuxResourcesCPUPeriod | train | func (g *Generator) SetLinuxResourcesCPUPeriod(period uint64) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.Period = &period
} | go | {
"resource": ""
} |
q14425 | SetLinuxResourcesCPURealtimeRuntime | train | func (g *Generator) SetLinuxResourcesCPURealtimeRuntime(time int64) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.RealtimeRuntime = &time
} | go | {
"resource": ""
} |
q14426 | SetLinuxResourcesCPURealtimePeriod | train | func (g *Generator) SetLinuxResourcesCPURealtimePeriod(period uint64) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.RealtimePeriod = &period
} | go | {
"resource": ""
} |
q14427 | SetLinuxResourcesCPUCpus | train | func (g *Generator) SetLinuxResourcesCPUCpus(cpus string) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.Cpus = cpus
} | go | {
"resource": ""
} |
q14428 | SetLinuxResourcesCPUMems | train | func (g *Generator) SetLinuxResourcesCPUMems(mems string) {
g.InitConfigLinuxResourcesCPU()
g.Config.Linux.Resources.CPU.Mems = mems
} | go | {
"resource": ""
} |
q14429 | AddLinuxResourcesHugepageLimit | train | func (g *Generator) AddLinuxResourcesHugepageLimit(pageSize string, limit uint64) {
hugepageLimit := rspec.LinuxHugepageLimit{
Pagesize: pageSize,
Limit: limit,
}
g.initConfigLinuxResources()
for i, pageLimit := range g.Config.Linux.Resources.HugepageLimits {
if pageLimit.Pagesize == pageSize {
g.Config.Linux.Resources.HugepageLimits[i].Limit = limit
return
}
}
g.Config.Linux.Resources.HugepageLimits = append(g.Config.Linux.Resources.HugepageLimits, hugepageLimit)
} | go | {
"resource": ""
} |
q14430 | DropLinuxResourcesHugepageLimit | train | func (g *Generator) DropLinuxResourcesHugepageLimit(pageSize string) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil {
return
}
for i, pageLimit := range g.Config.Linux.Resources.HugepageLimits {
if pageLimit.Pagesize == pageSize {
g.Config.Linux.Resources.HugepageLimits = append(g.Config.Linux.Resources.HugepageLimits[:i], g.Config.Linux.Resources.HugepageLimits[i+1:]...)
return
}
}
} | go | {
"resource": ""
} |
q14431 | SetLinuxResourcesMemoryLimit | train | func (g *Generator) SetLinuxResourcesMemoryLimit(limit int64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.Limit = &limit
} | go | {
"resource": ""
} |
q14432 | SetLinuxResourcesMemoryReservation | train | func (g *Generator) SetLinuxResourcesMemoryReservation(reservation int64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.Reservation = &reservation
} | go | {
"resource": ""
} |
q14433 | SetLinuxResourcesMemorySwap | train | func (g *Generator) SetLinuxResourcesMemorySwap(swap int64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.Swap = &swap
} | go | {
"resource": ""
} |
q14434 | SetLinuxResourcesMemoryKernel | train | func (g *Generator) SetLinuxResourcesMemoryKernel(kernel int64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.Kernel = &kernel
} | go | {
"resource": ""
} |
q14435 | SetLinuxResourcesMemoryKernelTCP | train | func (g *Generator) SetLinuxResourcesMemoryKernelTCP(kernelTCP int64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.KernelTCP = &kernelTCP
} | go | {
"resource": ""
} |
q14436 | SetLinuxResourcesMemorySwappiness | train | func (g *Generator) SetLinuxResourcesMemorySwappiness(swappiness uint64) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.Swappiness = &swappiness
} | go | {
"resource": ""
} |
q14437 | SetLinuxResourcesMemoryDisableOOMKiller | train | func (g *Generator) SetLinuxResourcesMemoryDisableOOMKiller(disable bool) {
g.initConfigLinuxResourcesMemory()
g.Config.Linux.Resources.Memory.DisableOOMKiller = &disable
} | go | {
"resource": ""
} |
q14438 | SetLinuxResourcesNetworkClassID | train | func (g *Generator) SetLinuxResourcesNetworkClassID(classid uint32) {
g.initConfigLinuxResourcesNetwork()
g.Config.Linux.Resources.Network.ClassID = &classid
} | go | {
"resource": ""
} |
q14439 | AddLinuxResourcesNetworkPriorities | train | func (g *Generator) AddLinuxResourcesNetworkPriorities(name string, prio uint32) {
g.initConfigLinuxResourcesNetwork()
for i, netPriority := range g.Config.Linux.Resources.Network.Priorities {
if netPriority.Name == name {
g.Config.Linux.Resources.Network.Priorities[i].Priority = prio
return
}
}
interfacePrio := new(rspec.LinuxInterfacePriority)
interfacePrio.Name = name
interfacePrio.Priority = prio
g.Config.Linux.Resources.Network.Priorities = append(g.Config.Linux.Resources.Network.Priorities, *interfacePrio)
} | go | {
"resource": ""
} |
q14440 | DropLinuxResourcesNetworkPriorities | train | func (g *Generator) DropLinuxResourcesNetworkPriorities(name string) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil || g.Config.Linux.Resources.Network == nil {
return
}
for i, netPriority := range g.Config.Linux.Resources.Network.Priorities {
if netPriority.Name == name {
g.Config.Linux.Resources.Network.Priorities = append(g.Config.Linux.Resources.Network.Priorities[:i], g.Config.Linux.Resources.Network.Priorities[i+1:]...)
return
}
}
} | go | {
"resource": ""
} |
q14441 | SetLinuxResourcesPidsLimit | train | func (g *Generator) SetLinuxResourcesPidsLimit(limit int64) {
g.initConfigLinuxResourcesPids()
g.Config.Linux.Resources.Pids.Limit = limit
} | go | {
"resource": ""
} |
q14442 | ClearLinuxSysctl | train | func (g *Generator) ClearLinuxSysctl() {
if g.Config == nil || g.Config.Linux == nil {
return
}
g.Config.Linux.Sysctl = make(map[string]string)
} | go | {
"resource": ""
} |
q14443 | AddLinuxSysctl | train | func (g *Generator) AddLinuxSysctl(key, value string) {
g.initConfigLinuxSysctl()
g.Config.Linux.Sysctl[key] = value
} | go | {
"resource": ""
} |
q14444 | RemoveLinuxSysctl | train | func (g *Generator) RemoveLinuxSysctl(key string) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Sysctl == nil {
return
}
delete(g.Config.Linux.Sysctl, key)
} | go | {
"resource": ""
} |
q14445 | ClearLinuxUIDMappings | train | func (g *Generator) ClearLinuxUIDMappings() {
if g.Config == nil || g.Config.Linux == nil {
return
}
g.Config.Linux.UIDMappings = []rspec.LinuxIDMapping{}
} | go | {
"resource": ""
} |
q14446 | AddLinuxUIDMapping | train | func (g *Generator) AddLinuxUIDMapping(hid, cid, size uint32) {
idMapping := rspec.LinuxIDMapping{
HostID: hid,
ContainerID: cid,
Size: size,
}
g.initConfigLinux()
g.Config.Linux.UIDMappings = append(g.Config.Linux.UIDMappings, idMapping)
} | go | {
"resource": ""
} |
q14447 | ClearLinuxGIDMappings | train | func (g *Generator) ClearLinuxGIDMappings() {
if g.Config == nil || g.Config.Linux == nil {
return
}
g.Config.Linux.GIDMappings = []rspec.LinuxIDMapping{}
} | go | {
"resource": ""
} |
q14448 | SetLinuxRootPropagation | train | func (g *Generator) SetLinuxRootPropagation(rp string) error {
switch rp {
case "":
case "private":
case "rprivate":
case "slave":
case "rslave":
case "shared":
case "rshared":
case "unbindable":
case "runbindable":
default:
return fmt.Errorf("rootfs-propagation %q must be empty or one of (r)private|(r)slave|(r)shared|(r)unbindable", rp)
}
g.initConfigLinux()
g.Config.Linux.RootfsPropagation = rp
return nil
} | go | {
"resource": ""
} |
q14449 | ClearPreStartHooks | train | func (g *Generator) ClearPreStartHooks() {
if g.Config == nil || g.Config.Hooks == nil {
return
}
g.Config.Hooks.Prestart = []rspec.Hook{}
} | go | {
"resource": ""
} |
q14450 | AddPreStartHook | train | func (g *Generator) AddPreStartHook(preStartHook rspec.Hook) error {
g.initConfigHooks()
g.Config.Hooks.Prestart = append(g.Config.Hooks.Prestart, preStartHook)
return nil
} | go | {
"resource": ""
} |
q14451 | ClearPostStopHooks | train | func (g *Generator) ClearPostStopHooks() {
if g.Config == nil || g.Config.Hooks == nil {
return
}
g.Config.Hooks.Poststop = []rspec.Hook{}
} | go | {
"resource": ""
} |
q14452 | AddPostStopHook | train | func (g *Generator) AddPostStopHook(postStopHook rspec.Hook) error {
g.initConfigHooks()
g.Config.Hooks.Poststop = append(g.Config.Hooks.Poststop, postStopHook)
return nil
} | go | {
"resource": ""
} |
q14453 | ClearPostStartHooks | train | func (g *Generator) ClearPostStartHooks() {
if g.Config == nil || g.Config.Hooks == nil {
return
}
g.Config.Hooks.Poststart = []rspec.Hook{}
} | go | {
"resource": ""
} |
q14454 | AddPostStartHook | train | func (g *Generator) AddPostStartHook(postStartHook rspec.Hook) error {
g.initConfigHooks()
g.Config.Hooks.Poststart = append(g.Config.Hooks.Poststart, postStartHook)
return nil
} | go | {
"resource": ""
} |
q14455 | AddMount | train | func (g *Generator) AddMount(mnt rspec.Mount) {
g.initConfig()
g.Config.Mounts = append(g.Config.Mounts, mnt)
} | go | {
"resource": ""
} |
q14456 | RemoveMount | train | func (g *Generator) RemoveMount(dest string) {
g.initConfig()
for index, mount := range g.Config.Mounts {
if mount.Destination == dest {
g.Config.Mounts = append(g.Config.Mounts[:index], g.Config.Mounts[index+1:]...)
return
}
}
} | go | {
"resource": ""
} |
q14457 | Mounts | train | func (g *Generator) Mounts() []rspec.Mount {
g.initConfig()
return g.Config.Mounts
} | go | {
"resource": ""
} |
q14458 | ClearMounts | train | func (g *Generator) ClearMounts() {
if g.Config == nil {
return
}
g.Config.Mounts = []rspec.Mount{}
} | go | {
"resource": ""
} |
q14459 | SetupPrivileged | train | func (g *Generator) SetupPrivileged(privileged bool) {
if privileged { // Add all capabilities in privileged mode.
var finalCapList []string
for _, cap := range capability.List() {
if g.HostSpecific && cap > validate.LastCap() {
continue
}
finalCapList = append(finalCapList, fmt.Sprintf("CAP_%s", strings.ToUpper(cap.String())))
}
g.initConfigLinux()
g.initConfigProcessCapabilities()
g.ClearProcessCapabilities()
g.Config.Process.Capabilities.Bounding = append(g.Config.Process.Capabilities.Bounding, finalCapList...)
g.Config.Process.Capabilities.Effective = append(g.Config.Process.Capabilities.Effective, finalCapList...)
g.Config.Process.Capabilities.Inheritable = append(g.Config.Process.Capabilities.Inheritable, finalCapList...)
g.Config.Process.Capabilities.Permitted = append(g.Config.Process.Capabilities.Permitted, finalCapList...)
g.Config.Process.Capabilities.Ambient = append(g.Config.Process.Capabilities.Ambient, finalCapList...)
g.Config.Process.SelinuxLabel = ""
g.Config.Process.ApparmorProfile = ""
g.Config.Linux.Seccomp = nil
}
} | go | {
"resource": ""
} |
q14460 | ClearProcessCapabilities | train | func (g *Generator) ClearProcessCapabilities() {
if g.Config == nil || g.Config.Process == nil || g.Config.Process.Capabilities == nil {
return
}
g.Config.Process.Capabilities.Bounding = []string{}
g.Config.Process.Capabilities.Effective = []string{}
g.Config.Process.Capabilities.Inheritable = []string{}
g.Config.Process.Capabilities.Permitted = []string{}
g.Config.Process.Capabilities.Ambient = []string{}
} | go | {
"resource": ""
} |
q14461 | AddProcessCapability | train | func (g *Generator) AddProcessCapability(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundAmbient, foundBounding, foundEffective, foundInheritable, foundPermitted bool
for _, cap := range g.Config.Process.Capabilities.Ambient {
if strings.ToUpper(cap) == cp {
foundAmbient = true
break
}
}
if !foundAmbient {
g.Config.Process.Capabilities.Ambient = append(g.Config.Process.Capabilities.Ambient, cp)
}
for _, cap := range g.Config.Process.Capabilities.Bounding {
if strings.ToUpper(cap) == cp {
foundBounding = true
break
}
}
if !foundBounding {
g.Config.Process.Capabilities.Bounding = append(g.Config.Process.Capabilities.Bounding, cp)
}
for _, cap := range g.Config.Process.Capabilities.Effective {
if strings.ToUpper(cap) == cp {
foundEffective = true
break
}
}
if !foundEffective {
g.Config.Process.Capabilities.Effective = append(g.Config.Process.Capabilities.Effective, cp)
}
for _, cap := range g.Config.Process.Capabilities.Inheritable {
if strings.ToUpper(cap) == cp {
foundInheritable = true
break
}
}
if !foundInheritable {
g.Config.Process.Capabilities.Inheritable = append(g.Config.Process.Capabilities.Inheritable, cp)
}
for _, cap := range g.Config.Process.Capabilities.Permitted {
if strings.ToUpper(cap) == cp {
foundPermitted = true
break
}
}
if !foundPermitted {
g.Config.Process.Capabilities.Permitted = append(g.Config.Process.Capabilities.Permitted, cp)
}
return nil
} | go | {
"resource": ""
} |
q14462 | AddProcessCapabilityAmbient | train | func (g *Generator) AddProcessCapabilityAmbient(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundAmbient bool
for _, cap := range g.Config.Process.Capabilities.Ambient {
if strings.ToUpper(cap) == cp {
foundAmbient = true
break
}
}
if !foundAmbient {
g.Config.Process.Capabilities.Ambient = append(g.Config.Process.Capabilities.Ambient, cp)
}
return nil
} | go | {
"resource": ""
} |
q14463 | AddProcessCapabilityBounding | train | func (g *Generator) AddProcessCapabilityBounding(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundBounding bool
for _, cap := range g.Config.Process.Capabilities.Bounding {
if strings.ToUpper(cap) == cp {
foundBounding = true
break
}
}
if !foundBounding {
g.Config.Process.Capabilities.Bounding = append(g.Config.Process.Capabilities.Bounding, cp)
}
return nil
} | go | {
"resource": ""
} |
q14464 | AddProcessCapabilityEffective | train | func (g *Generator) AddProcessCapabilityEffective(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundEffective bool
for _, cap := range g.Config.Process.Capabilities.Effective {
if strings.ToUpper(cap) == cp {
foundEffective = true
break
}
}
if !foundEffective {
g.Config.Process.Capabilities.Effective = append(g.Config.Process.Capabilities.Effective, cp)
}
return nil
} | go | {
"resource": ""
} |
q14465 | AddProcessCapabilityInheritable | train | func (g *Generator) AddProcessCapabilityInheritable(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundInheritable bool
for _, cap := range g.Config.Process.Capabilities.Inheritable {
if strings.ToUpper(cap) == cp {
foundInheritable = true
break
}
}
if !foundInheritable {
g.Config.Process.Capabilities.Inheritable = append(g.Config.Process.Capabilities.Inheritable, cp)
}
return nil
} | go | {
"resource": ""
} |
q14466 | AddProcessCapabilityPermitted | train | func (g *Generator) AddProcessCapabilityPermitted(c string) error {
cp := strings.ToUpper(c)
if err := validate.CapValid(cp, g.HostSpecific); err != nil {
return err
}
g.initConfigProcessCapabilities()
var foundPermitted bool
for _, cap := range g.Config.Process.Capabilities.Permitted {
if strings.ToUpper(cap) == cp {
foundPermitted = true
break
}
}
if !foundPermitted {
g.Config.Process.Capabilities.Permitted = append(g.Config.Process.Capabilities.Permitted, cp)
}
return nil
} | go | {
"resource": ""
} |
q14467 | DropProcessCapability | train | func (g *Generator) DropProcessCapability(c string) error {
if g.Config == nil || g.Config.Process == nil || g.Config.Process.Capabilities == nil {
return nil
}
cp := strings.ToUpper(c)
for i, cap := range g.Config.Process.Capabilities.Ambient {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Ambient = removeFunc(g.Config.Process.Capabilities.Ambient, i)
}
}
for i, cap := range g.Config.Process.Capabilities.Bounding {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Bounding = removeFunc(g.Config.Process.Capabilities.Bounding, i)
}
}
for i, cap := range g.Config.Process.Capabilities.Effective {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Effective = removeFunc(g.Config.Process.Capabilities.Effective, i)
}
}
for i, cap := range g.Config.Process.Capabilities.Inheritable {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Inheritable = removeFunc(g.Config.Process.Capabilities.Inheritable, i)
}
}
for i, cap := range g.Config.Process.Capabilities.Permitted {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Permitted = removeFunc(g.Config.Process.Capabilities.Permitted, i)
}
}
return validate.CapValid(cp, false)
} | go | {
"resource": ""
} |
q14468 | DropProcessCapabilityAmbient | train | func (g *Generator) DropProcessCapabilityAmbient(c string) error {
if g.Config == nil || g.Config.Process == nil || g.Config.Process.Capabilities == nil {
return nil
}
cp := strings.ToUpper(c)
for i, cap := range g.Config.Process.Capabilities.Ambient {
if strings.ToUpper(cap) == cp {
g.Config.Process.Capabilities.Ambient = removeFunc(g.Config.Process.Capabilities.Ambient, i)
}
}
return validate.CapValid(cp, false)
} | go | {
"resource": ""
} |
q14469 | ClearLinuxNamespaces | train | func (g *Generator) ClearLinuxNamespaces() {
if g.Config == nil || g.Config.Linux == nil {
return
}
g.Config.Linux.Namespaces = []rspec.LinuxNamespace{}
} | go | {
"resource": ""
} |
q14470 | AddOrReplaceLinuxNamespace | train | func (g *Generator) AddOrReplaceLinuxNamespace(ns string, path string) error {
namespace, err := mapStrToNamespace(ns, path)
if err != nil {
return err
}
g.initConfigLinux()
for i, ns := range g.Config.Linux.Namespaces {
if ns.Type == namespace.Type {
g.Config.Linux.Namespaces[i] = namespace
return nil
}
}
g.Config.Linux.Namespaces = append(g.Config.Linux.Namespaces, namespace)
return nil
} | go | {
"resource": ""
} |
q14471 | RemoveLinuxNamespace | train | func (g *Generator) RemoveLinuxNamespace(ns string) error {
namespace, err := mapStrToNamespace(ns, "")
if err != nil {
return err
}
if g.Config == nil || g.Config.Linux == nil {
return nil
}
for i, ns := range g.Config.Linux.Namespaces {
if ns.Type == namespace.Type {
g.Config.Linux.Namespaces = append(g.Config.Linux.Namespaces[:i], g.Config.Linux.Namespaces[i+1:]...)
return nil
}
}
return nil
} | go | {
"resource": ""
} |
q14472 | AddDevice | train | func (g *Generator) AddDevice(device rspec.LinuxDevice) {
g.initConfigLinux()
for i, dev := range g.Config.Linux.Devices {
if dev.Path == device.Path {
g.Config.Linux.Devices[i] = device
return
}
if dev.Type == device.Type && dev.Major == device.Major && dev.Minor == device.Minor {
fmt.Fprintln(os.Stderr, "WARNING: The same type, major and minor should not be used for multiple devices.")
}
}
g.Config.Linux.Devices = append(g.Config.Linux.Devices, device)
} | go | {
"resource": ""
} |
q14473 | RemoveDevice | train | func (g *Generator) RemoveDevice(path string) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Devices == nil {
return
}
for i, device := range g.Config.Linux.Devices {
if device.Path == path {
g.Config.Linux.Devices = append(g.Config.Linux.Devices[:i], g.Config.Linux.Devices[i+1:]...)
return
}
}
} | go | {
"resource": ""
} |
q14474 | ClearLinuxDevices | train | func (g *Generator) ClearLinuxDevices() {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Devices == nil {
return
}
g.Config.Linux.Devices = []rspec.LinuxDevice{}
} | go | {
"resource": ""
} |
q14475 | AddLinuxResourcesDevice | train | func (g *Generator) AddLinuxResourcesDevice(allow bool, devType string, major, minor *int64, access string) {
g.initConfigLinuxResources()
device := rspec.LinuxDeviceCgroup{
Allow: allow,
Type: devType,
Access: access,
Major: major,
Minor: minor,
}
g.Config.Linux.Resources.Devices = append(g.Config.Linux.Resources.Devices, device)
} | go | {
"resource": ""
} |
q14476 | RemoveLinuxResourcesDevice | train | func (g *Generator) RemoveLinuxResourcesDevice(allow bool, devType string, major, minor *int64, access string) {
if g.Config == nil || g.Config.Linux == nil || g.Config.Linux.Resources == nil {
return
}
for i, device := range g.Config.Linux.Resources.Devices {
if device.Allow == allow &&
(devType == device.Type || (devType != "" && device.Type != "" && devType == device.Type)) &&
(access == device.Access || (access != "" && device.Access != "" && access == device.Access)) &&
(major == device.Major || (major != nil && device.Major != nil && *major == *device.Major)) &&
(minor == device.Minor || (minor != nil && device.Minor != nil && *minor == *device.Minor)) {
g.Config.Linux.Resources.Devices = append(g.Config.Linux.Resources.Devices[:i], g.Config.Linux.Resources.Devices[i+1:]...)
return
}
}
return
} | go | {
"resource": ""
} |
q14477 | SetSyscallAction | train | func (g *Generator) SetSyscallAction(arguments seccomp.SyscallOpts) error {
g.initConfigLinuxSeccomp()
return seccomp.ParseSyscallFlag(arguments, g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14478 | SetDefaultSeccompAction | train | func (g *Generator) SetDefaultSeccompAction(action string) error {
g.initConfigLinuxSeccomp()
return seccomp.ParseDefaultAction(action, g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14479 | SetDefaultSeccompActionForce | train | func (g *Generator) SetDefaultSeccompActionForce(action string) error {
g.initConfigLinuxSeccomp()
return seccomp.ParseDefaultActionForce(action, g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14480 | SetSeccompArchitecture | train | func (g *Generator) SetSeccompArchitecture(architecture string) error {
g.initConfigLinuxSeccomp()
return seccomp.ParseArchitectureFlag(architecture, g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14481 | RemoveSeccompRule | train | func (g *Generator) RemoveSeccompRule(arguments string) error {
g.initConfigLinuxSeccomp()
return seccomp.RemoveAction(arguments, g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14482 | RemoveAllSeccompRules | train | func (g *Generator) RemoveAllSeccompRules() error {
g.initConfigLinuxSeccomp()
return seccomp.RemoveAllSeccompRules(g.Config.Linux.Seccomp)
} | go | {
"resource": ""
} |
q14483 | AddLinuxMaskedPaths | train | func (g *Generator) AddLinuxMaskedPaths(path string) {
g.initConfigLinux()
g.Config.Linux.MaskedPaths = append(g.Config.Linux.MaskedPaths, path)
} | go | {
"resource": ""
} |
q14484 | AddLinuxReadonlyPaths | train | func (g *Generator) AddLinuxReadonlyPaths(path string) {
g.initConfigLinux()
g.Config.Linux.ReadonlyPaths = append(g.Config.Linux.ReadonlyPaths, path)
} | go | {
"resource": ""
} |
q14485 | AddSolarisAnet | train | func (g *Generator) AddSolarisAnet(anet rspec.SolarisAnet) {
g.initConfigSolaris()
g.Config.Solaris.Anet = append(g.Config.Solaris.Anet, anet)
} | go | {
"resource": ""
} |
q14486 | SetSolarisCappedCPUNcpus | train | func (g *Generator) SetSolarisCappedCPUNcpus(ncpus string) {
g.initConfigSolarisCappedCPU()
g.Config.Solaris.CappedCPU.Ncpus = ncpus
} | go | {
"resource": ""
} |
q14487 | SetSolarisCappedMemoryPhysical | train | func (g *Generator) SetSolarisCappedMemoryPhysical(physical string) {
g.initConfigSolarisCappedMemory()
g.Config.Solaris.CappedMemory.Physical = physical
} | go | {
"resource": ""
} |
q14488 | SetSolarisCappedMemorySwap | train | func (g *Generator) SetSolarisCappedMemorySwap(swap string) {
g.initConfigSolarisCappedMemory()
g.Config.Solaris.CappedMemory.Swap = swap
} | go | {
"resource": ""
} |
q14489 | SetSolarisLimitPriv | train | func (g *Generator) SetSolarisLimitPriv(limitPriv string) {
g.initConfigSolaris()
g.Config.Solaris.LimitPriv = limitPriv
} | go | {
"resource": ""
} |
q14490 | SetSolarisMaxShmMemory | train | func (g *Generator) SetSolarisMaxShmMemory(memory string) {
g.initConfigSolaris()
g.Config.Solaris.MaxShmMemory = memory
} | go | {
"resource": ""
} |
q14491 | SetSolarisMilestone | train | func (g *Generator) SetSolarisMilestone(milestone string) {
g.initConfigSolaris()
g.Config.Solaris.Milestone = milestone
} | go | {
"resource": ""
} |
q14492 | SetVMHypervisorPath | train | func (g *Generator) SetVMHypervisorPath(path string) error {
if !strings.HasPrefix(path, "/") {
return fmt.Errorf("hypervisorPath %v is not an absolute path", path)
}
g.initConfigVMHypervisor()
g.Config.VM.Hypervisor.Path = path
return nil
} | go | {
"resource": ""
} |
q14493 | SetVMHypervisorParameters | train | func (g *Generator) SetVMHypervisorParameters(parameters []string) {
g.initConfigVMHypervisor()
g.Config.VM.Hypervisor.Parameters = parameters
} | go | {
"resource": ""
} |
q14494 | SetVMKernelPath | train | func (g *Generator) SetVMKernelPath(path string) error {
if !strings.HasPrefix(path, "/") {
return fmt.Errorf("kernelPath %v is not an absolute path", path)
}
g.initConfigVMKernel()
g.Config.VM.Kernel.Path = path
return nil
} | go | {
"resource": ""
} |
q14495 | SetVMKernelParameters | train | func (g *Generator) SetVMKernelParameters(parameters []string) {
g.initConfigVMKernel()
g.Config.VM.Kernel.Parameters = parameters
} | go | {
"resource": ""
} |
q14496 | SetVMKernelInitRD | train | func (g *Generator) SetVMKernelInitRD(initrd string) error {
if !strings.HasPrefix(initrd, "/") {
return fmt.Errorf("kernelInitrd %v is not an absolute path", initrd)
}
g.initConfigVMKernel()
g.Config.VM.Kernel.InitRD = initrd
return nil
} | go | {
"resource": ""
} |
q14497 | SetVMImagePath | train | func (g *Generator) SetVMImagePath(path string) error {
if !strings.HasPrefix(path, "/") {
return fmt.Errorf("imagePath %v is not an absolute path", path)
}
g.initConfigVMImage()
g.Config.VM.Image.Path = path
return nil
} | go | {
"resource": ""
} |
q14498 | SetVMImageFormat | train | func (g *Generator) SetVMImageFormat(format string) error {
switch format {
case "raw":
case "qcow2":
case "vdi":
case "vmdk":
case "vhd":
default:
return fmt.Errorf("Commonly supported formats are: raw, qcow2, vdi, vmdk, vhd")
}
g.initConfigVMImage()
g.Config.VM.Image.Format = format
return nil
} | go | {
"resource": ""
} |
q14499 | SetWindowsHypervUntilityVMPath | train | func (g *Generator) SetWindowsHypervUntilityVMPath(path string) {
g.initConfigWindowsHyperV()
g.Config.Windows.HyperV.UtilityVMPath = path
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.