Package io.github.alersrt.pod4j.openapi.model

Class SpecGenerator

java.lang.Object
io.github.alersrt.pod4j.openapi.model.SpecGenerator
@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen", date="2024-11-29T01:29:49.168634544+07:00[Asia/Barnaul]", comments="Generator version: 7.7.0") public class SpecGenerator extends Object
SpecGenerator creates an OCI spec and Libpod configuration options to create a container based on the given configuration.

  • Field Details

  • Constructor Details

    • SpecGenerator

      public SpecGenerator()

  • Method Details

    • validateJsonElement

      public static void validateJsonElement(com.google.gson.JsonElement jsonElement) throws IOException
      Validates the JSON Element and throws an exception if issues found
      Parameters:
      jsonElement - JSON Element
      Throws:
      IOException - if the JSON Element is invalid with respect to SpecGenerator

    • fromJson

      public static SpecGenerator fromJson(String jsonString) throws IOException
      Create an instance of SpecGenerator given an JSON string
      Parameters:
      jsonString - JSON string
      Returns:
      An instance of SpecGenerator
      Throws:
      IOException - if the JSON string is invalid with respect to SpecGenerator

    • networks

      public SpecGenerator networks(Map<String,PerNetworkOptions> networks)

    • putNetworksItem

      public SpecGenerator putNetworksItem(String key, PerNetworkOptions networksItem)

    • getNetworks

      @Nullable @Valid public @Valid Map<String,PerNetworkOptions> getNetworks()
      Map of networks names or ids that the container should join. You can request additional settings for each network, you can set network aliases, static ips, static mac address and the network interface name for this container on the specific network. If the map is empty and the bridge network mode is set the container will be joined to the default network. Optional.
      Returns:
      networks

    • setNetworks

      public void setNetworks(Map<String,PerNetworkOptions> networks)

    • annotations

      public SpecGenerator annotations(Map<String,String> annotations)

    • putAnnotationsItem

      public SpecGenerator putAnnotationsItem(String key, String annotationsItem)

    • getAnnotations

      @Nullable public Map<String,String> getAnnotations()
      Annotations are key-value options passed into the container runtime that can be used to trigger special behavior. Optional.
      Returns:
      annotations

    • setAnnotations

      public void setAnnotations(Map<String,String> annotations)

    • apparmorProfile

      public SpecGenerator apparmorProfile(String apparmorProfile)

    • getApparmorProfile

      @Nullable public String getApparmorProfile()
      ApparmorProfile is the name of the Apparmor profile the container will use. Optional.
      Returns:
      apparmorProfile

    • setApparmorProfile

      public void setApparmorProfile(String apparmorProfile)

    • baseHostsFile

      public SpecGenerator baseHostsFile(String baseHostsFile)

    • getBaseHostsFile

      @Nullable public String getBaseHostsFile()
      BaseHostsFile is the path to a hosts file, the entries from this file are added to the containers hosts file. As special value \"image\" is allowed which uses the /etc/hosts file from within the image and \"none\" which uses no base file at all. If it is empty we should default to the base_hosts_file configuration in containers.conf. Optional.
      Returns:
      baseHostsFile

    • setBaseHostsFile

      public void setBaseHostsFile(String baseHostsFile)

    • capAdd

      public SpecGenerator capAdd(List<String> capAdd)

    • addCapAddItem

      public SpecGenerator addCapAddItem(String capAddItem)

    • getCapAdd

      @Nullable public List<String> getCapAdd()
      CapAdd are capabilities which will be added to the container. Conflicts with Privileged. Optional.
      Returns:
      capAdd

    • setCapAdd

      public void setCapAdd(List<String> capAdd)

    • capDrop

      public SpecGenerator capDrop(List<String> capDrop)

    • addCapDropItem

      public SpecGenerator addCapDropItem(String capDropItem)

    • getCapDrop

      @Nullable public List<String> getCapDrop()
      CapDrop are capabilities which will be removed from the container. Conflicts with Privileged. Optional.
      Returns:
      capDrop

    • setCapDrop

      public void setCapDrop(List<String> capDrop)

    • cgroupParent

      public SpecGenerator cgroupParent(String cgroupParent)

    • getCgroupParent

      @Nullable public String getCgroupParent()
      CgroupParent is the container's Cgroup parent. If not set, the default for the current cgroup driver will be used. Optional.
      Returns:
      cgroupParent

    • setCgroupParent

      public void setCgroupParent(String cgroupParent)

    • cgroupns

      public SpecGenerator cgroupns(Namespace cgroupns)

    • getCgroupns

      @Nullable @Valid public @Valid Namespace getCgroupns()
      Get cgroupns
      Returns:
      cgroupns

    • setCgroupns

      public void setCgroupns(Namespace cgroupns)

    • cgroupsMode

      public SpecGenerator cgroupsMode(String cgroupsMode)

    • getCgroupsMode

      @Nullable public String getCgroupsMode()
      CgroupsMode sets a policy for how cgroups will be created for the container, including the ability to disable creation entirely. Optional.
      Returns:
      cgroupsMode

    • setCgroupsMode

      public void setCgroupsMode(String cgroupsMode)

    • chrootDirectories

      public SpecGenerator chrootDirectories(List<String> chrootDirectories)

    • addChrootDirectoriesItem

      public SpecGenerator addChrootDirectoriesItem(String chrootDirectoriesItem)

    • getChrootDirectories

      @Nullable public List<String> getChrootDirectories()
      ChrootDirs is an additional set of directories that need to be treated as root directories. Standard bind mounts will be mounted into paths relative to these directories. Optional.
      Returns:
      chrootDirectories

    • setChrootDirectories

      public void setChrootDirectories(List<String> chrootDirectories)

    • cniNetworks

      public SpecGenerator cniNetworks(List<String> cniNetworks)

    • addCniNetworksItem

      public SpecGenerator addCniNetworksItem(String cniNetworksItem)

    • getCniNetworks

      @Nullable public List<String> getCniNetworks()
      CNINetworks is a list of CNI networks to join the container to. If this list is empty, the default CNI network will be joined instead. If at least one entry is present, we will not join the default network (unless it is part of this list). Only available if NetNS is set to bridge. Optional. Deprecated: as of podman 4.0 use \"Networks\" instead.
      Returns:
      cniNetworks

    • setCniNetworks

      public void setCniNetworks(List<String> cniNetworks)

    • command

      public SpecGenerator command(List<String> command)

    • addCommandItem

      public SpecGenerator addCommandItem(String commandItem)

    • getCommand

      @Nullable public List<String> getCommand()
      Command is the container's command. If not given and Image is specified, this will be populated by the image's configuration. Optional.
      Returns:
      command

    • setCommand

      public void setCommand(List<String> command)

    • conmonPidFile

      public SpecGenerator conmonPidFile(String conmonPidFile)

    • getConmonPidFile

      @Nullable public String getConmonPidFile()
      ConmonPidFile is a path at which a PID file for Conmon will be placed. If not given, a default location will be used. Optional.
      Returns:
      conmonPidFile

    • setConmonPidFile

      public void setConmonPidFile(String conmonPidFile)

    • containerCreateCommand

      public SpecGenerator containerCreateCommand(List<String> containerCreateCommand)

    • addContainerCreateCommandItem

      public SpecGenerator addContainerCreateCommandItem(String containerCreateCommandItem)

    • getContainerCreateCommand

      @Nullable public List<String> getContainerCreateCommand()
      ContainerCreateCommand is the command that was used to create this container. This will be shown in the output of Inspect() on the container, and may also be used by some tools that wish to recreate the container (e.g. `podman generate systemd --new`). Optional.
      Returns:
      containerCreateCommand

    • setContainerCreateCommand

      public void setContainerCreateCommand(List<String> containerCreateCommand)

    • createWorkingDir

      public SpecGenerator createWorkingDir(Boolean createWorkingDir)

    • getCreateWorkingDir

      @Nullable public Boolean getCreateWorkingDir()
      Create the working directory if it doesn't exist. If unset, it doesn't create it. Optional.
      Returns:
      createWorkingDir

    • setCreateWorkingDir

      public void setCreateWorkingDir(Boolean createWorkingDir)

    • dependencyContainers

      public SpecGenerator dependencyContainers(List<String> dependencyContainers)

    • addDependencyContainersItem

      public SpecGenerator addDependencyContainersItem(String dependencyContainersItem)

    • getDependencyContainers

      @Nullable public List<String> getDependencyContainers()
      DependencyContainers is an array of containers this container depends on. Dependency containers must be started before this container. Dependencies can be specified by name or full/partial ID. Optional.
      Returns:
      dependencyContainers

    • setDependencyContainers

      public void setDependencyContainers(List<String> dependencyContainers)

    • deviceCgroupRule

      public SpecGenerator deviceCgroupRule(List<@Valid LinuxDeviceCgroup> deviceCgroupRule)

    • addDeviceCgroupRuleItem

      public SpecGenerator addDeviceCgroupRuleItem(LinuxDeviceCgroup deviceCgroupRuleItem)

    • getDeviceCgroupRule

      @Nullable @Valid public @Valid List<@Valid LinuxDeviceCgroup> getDeviceCgroupRule()
      DeviceCgroupRule are device cgroup rules that allow containers to use additional types of devices.
      Returns:
      deviceCgroupRule

    • setDeviceCgroupRule

      public void setDeviceCgroupRule(List<@Valid LinuxDeviceCgroup> deviceCgroupRule)

    • devices

      public SpecGenerator devices(List<@Valid LinuxDevice> devices)

    • addDevicesItem

      public SpecGenerator addDevicesItem(LinuxDevice devicesItem)

    • getDevices

      @Nullable @Valid public @Valid List<@Valid LinuxDevice> getDevices()
      Devices are devices that will be added to the container. Optional.
      Returns:
      devices

    • setDevices

      public void setDevices(List<@Valid LinuxDevice> devices)

    • devicesFrom

      public SpecGenerator devicesFrom(List<String> devicesFrom)

    • addDevicesFromItem

      public SpecGenerator addDevicesFromItem(String devicesFromItem)

    • getDevicesFrom

      @Nullable public List<String> getDevicesFrom()
      DevicesFrom specifies that this container will mount the device(s) from other container(s). Optional.
      Returns:
      devicesFrom

    • setDevicesFrom

      public void setDevicesFrom(List<String> devicesFrom)

    • dnsOption

      public SpecGenerator dnsOption(List<String> dnsOption)

    • addDnsOptionItem

      public SpecGenerator addDnsOptionItem(String dnsOptionItem)

    • getDnsOption

      @Nullable public List<String> getDnsOption()
      DNSOptions is a set of DNS options that will be used in the container's resolv.conf, replacing the host's DNS options which are used by default. Conflicts with UseImageResolvConf. Optional.
      Returns:
      dnsOption

    • setDnsOption

      public void setDnsOption(List<String> dnsOption)

    • dnsSearch

      public SpecGenerator dnsSearch(List<String> dnsSearch)

    • addDnsSearchItem

      public SpecGenerator addDnsSearchItem(String dnsSearchItem)

    • getDnsSearch

      @Nullable public List<String> getDnsSearch()
      DNSSearch is a set of DNS search domains that will be used in the container's resolv.conf, replacing the host's DNS search domains which are used by default. Conflicts with UseImageResolvConf. Optional.
      Returns:
      dnsSearch

    • setDnsSearch

      public void setDnsSearch(List<String> dnsSearch)

    • dnsServer

      public SpecGenerator dnsServer(List<String> dnsServer)

    • addDnsServerItem

      public SpecGenerator addDnsServerItem(String dnsServerItem)

    • getDnsServer

      @Nullable public List<String> getDnsServer()
      DNSServers is a set of DNS servers that will be used in the container's resolv.conf, replacing the host's DNS Servers which are used by default. Conflicts with UseImageResolvConf. Optional.
      Returns:
      dnsServer

    • setDnsServer

      public void setDnsServer(List<String> dnsServer)

    • entrypoint

      public SpecGenerator entrypoint(List<String> entrypoint)

    • addEntrypointItem

      public SpecGenerator addEntrypointItem(String entrypointItem)

    • getEntrypoint

      @Nullable public List<String> getEntrypoint()
      Entrypoint is the container's entrypoint. If not given and Image is specified, this will be populated by the image's configuration. Optional.
      Returns:
      entrypoint

    • setEntrypoint

      public void setEntrypoint(List<String> entrypoint)

    • env

      public SpecGenerator env(Map<String,String> env)

    • putEnvItem

      public SpecGenerator putEnvItem(String key, String envItem)

    • getEnv

      @Nullable public Map<String,String> getEnv()
      Env is a set of environment variables that will be set in the container. Optional.
      Returns:
      env

    • setEnv

      public void setEnv(Map<String,String> env)

    • envHost

      public SpecGenerator envHost(Boolean envHost)

    • getEnvHost

      @Nullable public Boolean getEnvHost()
      EnvHost indicates that the host environment should be added to container Optional.
      Returns:
      envHost

    • setEnvHost

      public void setEnvHost(Boolean envHost)

    • envmerge

      public SpecGenerator envmerge(List<String> envmerge)

    • addEnvmergeItem

      public SpecGenerator addEnvmergeItem(String envmergeItem)

    • getEnvmerge

      @Nullable public List<String> getEnvmerge()
      EnvMerge takes the specified environment variables from image and preprocess them before injecting them into the container. Optional.
      Returns:
      envmerge

    • setEnvmerge

      public void setEnvmerge(List<String> envmerge)

    • expose

      public SpecGenerator expose(Object expose)

    • getExpose

      @Nullable public Object getExpose()
      Expose is a number of ports that will be forwarded to the container if PublishExposedPorts is set. Expose is a map of uint16 (port number) to a string representing protocol i.e map[uint16]string. Allowed protocols are \"tcp\", \"udp\", and \"sctp\", or some combination of the three separated by commas. If protocol is set to \"\" we will assume TCP. Only available if NetNS is set to Bridge or Slirp, and PublishExposedPorts is set. Optional.
      Returns:
      expose

    • setExpose

      public void setExpose(Object expose)

    • groupEntry

      public SpecGenerator groupEntry(String groupEntry)

    • getGroupEntry

      @Nullable public String getGroupEntry()
      GroupEntry specifies an arbitrary string to append to the container's /etc/group file. Optional.
      Returns:
      groupEntry

    • setGroupEntry

      public void setGroupEntry(String groupEntry)

    • groups

      public SpecGenerator groups(List<String> groups)

    • addGroupsItem

      public SpecGenerator addGroupsItem(String groupsItem)

    • getGroups

      @Nullable public List<String> getGroups()
      Groups are a list of supplemental groups the container's user will be granted access to. Optional.
      Returns:
      groups

    • setGroups

      public void setGroups(List<String> groups)

    • healthCheckOnFailureAction

      public SpecGenerator healthCheckOnFailureAction(Long healthCheckOnFailureAction)

    • getHealthCheckOnFailureAction

      @Nullable public Long getHealthCheckOnFailureAction()
      HealthCheckOnFailureAction defines how Podman reacts when a container's health status turns unhealthy.
      Returns:
      healthCheckOnFailureAction

    • setHealthCheckOnFailureAction

      public void setHealthCheckOnFailureAction(Long healthCheckOnFailureAction)

    • healthLogDestination

      public SpecGenerator healthLogDestination(String healthLogDestination)

    • getHealthLogDestination

      @Nullable public String getHealthLogDestination()
      HealthLogDestination defines the destination where the log is stored
      Returns:
      healthLogDestination

    • setHealthLogDestination

      public void setHealthLogDestination(String healthLogDestination)

    • healthMaxLogCount

      public SpecGenerator healthMaxLogCount(Integer healthMaxLogCount)

    • getHealthMaxLogCount

      @Nullable public Integer getHealthMaxLogCount()
      HealthMaxLogCount is maximum number of attempts in the HealthCheck log file. ('0' value means an infinite number of attempts in the log file)
      Returns:
      healthMaxLogCount

    • setHealthMaxLogCount

      public void setHealthMaxLogCount(Integer healthMaxLogCount)

    • healthMaxLogSize

      public SpecGenerator healthMaxLogSize(Integer healthMaxLogSize)

    • getHealthMaxLogSize

      @Nullable public Integer getHealthMaxLogSize()
      HealthMaxLogSize is the maximum length in characters of stored HealthCheck log (\"0\" value means an infinite log length)
      Returns:
      healthMaxLogSize

    • setHealthMaxLogSize

      public void setHealthMaxLogSize(Integer healthMaxLogSize)

    • healthconfig

      public SpecGenerator healthconfig(Schema2HealthConfig healthconfig)

    • getHealthconfig

      @Nullable @Valid public @Valid Schema2HealthConfig getHealthconfig()
      Get healthconfig
      Returns:
      healthconfig

    • setHealthconfig

      public void setHealthconfig(Schema2HealthConfig healthconfig)

    • hostDeviceList

      public SpecGenerator hostDeviceList(List<@Valid LinuxDevice> hostDeviceList)

    • addHostDeviceListItem

      public SpecGenerator addHostDeviceListItem(LinuxDevice hostDeviceListItem)

    • getHostDeviceList

      @Nullable @Valid public @Valid List<@Valid LinuxDevice> getHostDeviceList()
      HostDeviceList is used to recreate the mounted device on inherited containers
      Returns:
      hostDeviceList

    • setHostDeviceList

      public void setHostDeviceList(List<@Valid LinuxDevice> hostDeviceList)

    • hostadd

      public SpecGenerator hostadd(List<String> hostadd)

    • addHostaddItem

      public SpecGenerator addHostaddItem(String hostaddItem)

    • getHostadd

      @Nullable public List<String> getHostadd()
      HostAdd is a set of hosts which will be added to the container's etc/hosts file. Conflicts with UseImageHosts. Optional.
      Returns:
      hostadd

    • setHostadd

      public void setHostadd(List<String> hostadd)

    • hostname

      public SpecGenerator hostname(String hostname)

    • getHostname

      @Nullable public String getHostname()
      Hostname is the container's hostname. If not set, the hostname will not be modified (if UtsNS is not private) or will be set to the container ID (if UtsNS is private). Conflicts with UtsNS if UtsNS is not set to private. Optional.
      Returns:
      hostname

    • setHostname

      public void setHostname(String hostname)

    • hostusers

      public SpecGenerator hostusers(List<String> hostusers)

    • addHostusersItem

      public SpecGenerator addHostusersItem(String hostusersItem)

    • getHostusers

      @Nullable public List<String> getHostusers()
      HostUsers is a list of host usernames or UIDs to add to the container etc/passwd file
      Returns:
      hostusers

    • setHostusers

      public void setHostusers(List<String> hostusers)

    • httpproxy

      public SpecGenerator httpproxy(Boolean httpproxy)

    • getHttpproxy

      @Nullable public Boolean getHttpproxy()
      EnvHTTPProxy indicates that the http host proxy environment variables should be added to container Optional.
      Returns:
      httpproxy

    • setHttpproxy

      public void setHttpproxy(Boolean httpproxy)

    • idmappings

      public SpecGenerator idmappings(IDMappingOptions idmappings)

    • getIdmappings

      @Nullable @Valid public @Valid IDMappingOptions getIdmappings()
      Get idmappings
      Returns:
      idmappings

    • setIdmappings

      public void setIdmappings(IDMappingOptions idmappings)

    • image

      public SpecGenerator image(String image)

    • getImage

      @Nullable public String getImage()
      Image is the image the container will be based on. The image will be used as the container's root filesystem, and its environment vars, volumes, and other configuration will be applied to the container. Conflicts with Rootfs. At least one of Image or Rootfs must be specified.
      Returns:
      image

    • setImage

      public void setImage(String image)

    • imageArch

      public SpecGenerator imageArch(String imageArch)

    • getImageArch

      @Nullable public String getImageArch()
      ImageArch is the user-specified image architecture. Used to select a different variant from a manifest list. Optional.
      Returns:
      imageArch

    • setImageArch

      public void setImageArch(String imageArch)

    • imageOs

      public SpecGenerator imageOs(String imageOs)

    • getImageOs

      @Nullable public String getImageOs()
      ImageOS is the user-specified OS of the image. Used to select a different variant from a manifest list. Optional.
      Returns:
      imageOs

    • setImageOs

      public void setImageOs(String imageOs)

    • imageVariant

      public SpecGenerator imageVariant(String imageVariant)

    • getImageVariant

      @Nullable public String getImageVariant()
      ImageVariant is the user-specified image variant. Used to select a different variant from a manifest list. Optional.
      Returns:
      imageVariant

    • setImageVariant

      public void setImageVariant(String imageVariant)

    • imageVolumeMode

      public SpecGenerator imageVolumeMode(String imageVolumeMode)

    • getImageVolumeMode

      @Nullable public String getImageVolumeMode()
      ImageVolumeMode indicates how image volumes will be created. Supported modes are \"ignore\" (do not create), \"tmpfs\" (create as tmpfs), and \"anonymous\" (create as anonymous volumes). The default if unset is anonymous. Optional.
      Returns:
      imageVolumeMode

    • setImageVolumeMode

      public void setImageVolumeMode(String imageVolumeMode)

    • imageVolumes

      public SpecGenerator imageVolumes(List<@Valid ImageVolume> imageVolumes)

    • addImageVolumesItem

      public SpecGenerator addImageVolumesItem(ImageVolume imageVolumesItem)

    • getImageVolumes

      @Nullable @Valid public @Valid List<@Valid ImageVolume> getImageVolumes()
      Image volumes bind-mount a container-image mount into the container. Optional.
      Returns:
      imageVolumes

    • setImageVolumes

      public void setImageVolumes(List<@Valid ImageVolume> imageVolumes)

    • init

      public SpecGenerator init(Boolean init)

    • getInit

      @Nullable public Boolean getInit()
      Init specifies that an init binary will be mounted into the container, and will be used as PID1. Optional.
      Returns:
      init

    • setInit

      public void setInit(Boolean init)

    • initContainerType

      public SpecGenerator initContainerType(String initContainerType)

    • getInitContainerType

      @Nullable public String getInitContainerType()
      InitContainerType describes if this container is an init container and if so, what type: always or once. Optional.
      Returns:
      initContainerType

    • setInitContainerType

      public void setInitContainerType(String initContainerType)

    • initPath

      public SpecGenerator initPath(String initPath)

    • getInitPath

      @Nullable public String getInitPath()
      InitPath specifies the path to the init binary that will be added if Init is specified above. If not specified, the default set in the Libpod config will be used. Ignored if Init above is not set. Optional.
      Returns:
      initPath

    • setInitPath

      public void setInitPath(String initPath)

    • intelRdt

      public SpecGenerator intelRdt(LinuxIntelRdt intelRdt)

    • getIntelRdt

      @Nullable @Valid public @Valid LinuxIntelRdt getIntelRdt()
      Get intelRdt
      Returns:
      intelRdt

    • setIntelRdt

      public void setIntelRdt(LinuxIntelRdt intelRdt)

    • ipcns

      public SpecGenerator ipcns(Namespace ipcns)

    • getIpcns

      @Nullable @Valid public @Valid Namespace getIpcns()
      Get ipcns
      Returns:
      ipcns

    • setIpcns

      public void setIpcns(Namespace ipcns)

    • labelNested

      public SpecGenerator labelNested(Boolean labelNested)

    • getLabelNested

      @Nullable public Boolean getLabelNested()
      LabelNested indicates whether or not the container is allowed to run fully nested containers including SELinux labelling. Optional.
      Returns:
      labelNested

    • setLabelNested

      public void setLabelNested(Boolean labelNested)

    • labels

      public SpecGenerator labels(Map<String,String> labels)

    • putLabelsItem

      public SpecGenerator putLabelsItem(String key, String labelsItem)

    • getLabels

      @Nullable public Map<String,String> getLabels()
      Labels are key-value pairs that are used to add metadata to containers. Optional.
      Returns:
      labels

    • setLabels

      public void setLabels(Map<String,String> labels)

    • logConfiguration

      public SpecGenerator logConfiguration(LogConfigLibpod logConfiguration)

    • getLogConfiguration

      @Nullable @Valid public @Valid LogConfigLibpod getLogConfiguration()
      Get logConfiguration
      Returns:
      logConfiguration

    • setLogConfiguration

      public void setLogConfiguration(LogConfigLibpod logConfiguration)

    • managePassword

      public SpecGenerator managePassword(Boolean managePassword)

    • getManagePassword

      @Nullable public Boolean getManagePassword()
      Passwd is a container run option that determines if we are validating users/groups before running the container
      Returns:
      managePassword

    • setManagePassword

      public void setManagePassword(Boolean managePassword)

    • mask

      public SpecGenerator mask(List<String> mask)

    • addMaskItem

      public SpecGenerator addMaskItem(String maskItem)

    • getMask

      @Nullable public List<String> getMask()
      Mask is the path we want to mask in the container. This masks the paths given in addition to the default list. Optional
      Returns:
      mask

    • setMask

      public void setMask(List<String> mask)

    • mounts

      public SpecGenerator mounts(List<@Valid Mount> mounts)

    • addMountsItem

      public SpecGenerator addMountsItem(Mount mountsItem)

    • getMounts

      @Nullable @Valid public @Valid List<@Valid Mount> getMounts()
      Mounts are mounts that will be added to the container. These will supersede Image Volumes and VolumesFrom volumes where there are conflicts. Optional.
      Returns:
      mounts

    • setMounts

      public void setMounts(List<@Valid Mount> mounts)

    • name

      public SpecGenerator name(String name)

    • getName

      @Nullable public String getName()
      Name is the name the container will be given. If no name is provided, one will be randomly generated. Optional.
      Returns:
      name

    • setName

      public void setName(String name)

    • netns

      public SpecGenerator netns(Namespace netns)

    • getNetns

      @Nullable @Valid public @Valid Namespace getNetns()
      Get netns
      Returns:
      netns

    • setNetns

      public void setNetns(Namespace netns)

    • networkOptions

      public SpecGenerator networkOptions(Map<String,List<String>> networkOptions)

    • putNetworkOptionsItem

      public SpecGenerator putNetworkOptionsItem(String key, List<String> networkOptionsItem)

    • getNetworkOptions

      @Nullable @Valid public @Valid Map<String,List<String>> getNetworkOptions()
      NetworkOptions are additional options for each network Optional.
      Returns:
      networkOptions

    • setNetworkOptions

      public void setNetworkOptions(Map<String,List<String>> networkOptions)

    • noNewPrivileges

      public SpecGenerator noNewPrivileges(Boolean noNewPrivileges)

    • getNoNewPrivileges

      @Nullable public Boolean getNoNewPrivileges()
      NoNewPrivileges is whether the container will set the no new privileges flag on create, which disables gaining additional privileges (e.g. via setuid) in the container. Optional.
      Returns:
      noNewPrivileges

    • setNoNewPrivileges

      public void setNoNewPrivileges(Boolean noNewPrivileges)

    • ociRuntime

      public SpecGenerator ociRuntime(String ociRuntime)

    • getOciRuntime

      @Nullable public String getOciRuntime()
      OCIRuntime is the name of the OCI runtime that will be used to create the container. If not specified, the default will be used. Optional.
      Returns:
      ociRuntime

    • setOciRuntime

      public void setOciRuntime(String ociRuntime)

    • oomScoreAdj

      public SpecGenerator oomScoreAdj(Long oomScoreAdj)

    • getOomScoreAdj

      @Nullable public Long getOomScoreAdj()
      OOMScoreAdj adjusts the score used by the OOM killer to determine processes to kill for the container's process. Optional.
      Returns:
      oomScoreAdj

    • setOomScoreAdj

      public void setOomScoreAdj(Long oomScoreAdj)

    • overlayVolumes

      public SpecGenerator overlayVolumes(List<@Valid OverlayVolume> overlayVolumes)

    • addOverlayVolumesItem

      public SpecGenerator addOverlayVolumesItem(OverlayVolume overlayVolumesItem)

    • getOverlayVolumes

      @Nullable @Valid public @Valid List<@Valid OverlayVolume> getOverlayVolumes()
      Overlay volumes are named volumes that will be added to the container. Optional.
      Returns:
      overlayVolumes

    • setOverlayVolumes

      public void setOverlayVolumes(List<@Valid OverlayVolume> overlayVolumes)

    • passwdEntry

      public SpecGenerator passwdEntry(String passwdEntry)

    • getPasswdEntry

      @Nullable public String getPasswdEntry()
      PasswdEntry specifies an arbitrary string to append to the container's /etc/passwd file. Optional.
      Returns:
      passwdEntry

    • setPasswdEntry

      public void setPasswdEntry(String passwdEntry)

    • personality

      public SpecGenerator personality(LinuxPersonality personality)

    • getPersonality

      @Nullable @Valid public @Valid LinuxPersonality getPersonality()
      Get personality
      Returns:
      personality

    • setPersonality

      public void setPersonality(LinuxPersonality personality)

    • pidns

      public SpecGenerator pidns(Namespace pidns)

    • getPidns

      @Nullable @Valid public @Valid Namespace getPidns()
      Get pidns
      Returns:
      pidns

    • setPidns

      public void setPidns(Namespace pidns)

    • pod

      public SpecGenerator pod(String pod)

    • getPod

      @Nullable public String getPod()
      Pod is the ID of the pod the container will join. Optional.
      Returns:
      pod

    • setPod

      public void setPod(String pod)

    • portmappings

      public SpecGenerator portmappings(List<@Valid PortMapping> portmappings)

    • addPortmappingsItem

      public SpecGenerator addPortmappingsItem(PortMapping portmappingsItem)

    • getPortmappings

      @Nullable @Valid public @Valid List<@Valid PortMapping> getPortmappings()
      PortBindings is a set of ports to map into the container. Only available if NetNS is set to bridge, slirp, or pasta. Optional.
      Returns:
      portmappings

    • setPortmappings

      public void setPortmappings(List<@Valid PortMapping> portmappings)

    • privileged

      public SpecGenerator privileged(Boolean privileged)

    • getPrivileged

      @Nullable public Boolean getPrivileged()
      Privileged is whether the container is privileged. Privileged does the following: Adds all devices on the system to the container. Adds all capabilities to the container. Disables Seccomp, SELinux, and Apparmor confinement. (Though SELinux can be manually re-enabled). TODO: this conflicts with things. TODO: this does more. Optional.
      Returns:
      privileged

    • setPrivileged

      public void setPrivileged(Boolean privileged)

    • procfsOpts

      public SpecGenerator procfsOpts(List<String> procfsOpts)

    • addProcfsOptsItem

      public SpecGenerator addProcfsOptsItem(String procfsOptsItem)

    • getProcfsOpts

      @Nullable public List<String> getProcfsOpts()
      ProcOpts are the options used for the proc mount.
      Returns:
      procfsOpts

    • setProcfsOpts

      public void setProcfsOpts(List<String> procfsOpts)

    • publishImagePorts

      public SpecGenerator publishImagePorts(Boolean publishImagePorts)

    • getPublishImagePorts

      @Nullable public Boolean getPublishImagePorts()
      PublishExposedPorts will publish ports specified in the image to random unused ports (guaranteed to be above 1024) on the host. This is based on ports set in Expose below, and any ports specified by the Image (if one is given). Only available if NetNS is set to Bridge or Slirp. Optional.
      Returns:
      publishImagePorts

    • setPublishImagePorts

      public void setPublishImagePorts(Boolean publishImagePorts)

    • rLimits

      public SpecGenerator rLimits(List<@Valid POSIXRlimit> rLimits)

    • addRLimitsItem

      public SpecGenerator addRLimitsItem(POSIXRlimit rLimitsItem)

    • getrLimits

      @Nullable @Valid public @Valid List<@Valid POSIXRlimit> getrLimits()
      Rlimits are POSIX rlimits to apply to the container. Optional.
      Returns:
      rLimits

    • setrLimits

      public void setrLimits(List<@Valid POSIXRlimit> rLimits)

    • rawImageName

      public SpecGenerator rawImageName(String rawImageName)

    • getRawImageName

      @Nullable public String getRawImageName()
      RawImageName is the user-specified and unprocessed input referring to a local or a remote image. Optional, but strongly encouraged to be set if Image is set.
      Returns:
      rawImageName

    • setRawImageName

      public void setRawImageName(String rawImageName)

    • readOnlyFilesystem

      public SpecGenerator readOnlyFilesystem(Boolean readOnlyFilesystem)

    • getReadOnlyFilesystem

      @Nullable public Boolean getReadOnlyFilesystem()
      ReadOnlyFilesystem indicates that everything will be mounted as read-only. Optional.
      Returns:
      readOnlyFilesystem

    • setReadOnlyFilesystem

      public void setReadOnlyFilesystem(Boolean readOnlyFilesystem)

    • readWriteTmpfs

      public SpecGenerator readWriteTmpfs(Boolean readWriteTmpfs)

    • getReadWriteTmpfs

      @Nullable public Boolean getReadWriteTmpfs()
      ReadWriteTmpfs indicates that when running with a ReadOnlyFilesystem mount temporary file systems. Optional.
      Returns:
      readWriteTmpfs

    • setReadWriteTmpfs

      public void setReadWriteTmpfs(Boolean readWriteTmpfs)

    • remove

      public SpecGenerator remove(Boolean remove)

    • getRemove

      @Nullable public Boolean getRemove()
      Remove indicates if the container should be removed once it has been started and exits. Optional.
      Returns:
      remove

    • setRemove

      public void setRemove(Boolean remove)

    • removeImage

      public SpecGenerator removeImage(Boolean removeImage)

    • getRemoveImage

      @Nullable public Boolean getRemoveImage()
      RemoveImage indicates that the container should remove the image it was created from after it exits. Only allowed if Remove is set to true and Image, not Rootfs, is in use. Optional.
      Returns:
      removeImage

    • setRemoveImage

      public void setRemoveImage(Boolean removeImage)

    • resourceLimits

      public SpecGenerator resourceLimits(LinuxResources resourceLimits)

    • getResourceLimits

      @Nullable @Valid public @Valid LinuxResources getResourceLimits()
      Get resourceLimits
      Returns:
      resourceLimits

    • setResourceLimits

      public void setResourceLimits(LinuxResources resourceLimits)

    • restartPolicy

      public SpecGenerator restartPolicy(String restartPolicy)

    • getRestartPolicy

      @Nullable public String getRestartPolicy()
      RestartPolicy is the container's restart policy - an action which will be taken when the container exits. If not given, the default policy, which does nothing, will be used. Optional.
      Returns:
      restartPolicy

    • setRestartPolicy

      public void setRestartPolicy(String restartPolicy)

    • restartTries

      public SpecGenerator restartTries(Integer restartTries)

    • getRestartTries

      @Nullable public Integer getRestartTries()
      RestartRetries is the number of attempts that will be made to restart the container. Only available when RestartPolicy is set to \"on-failure\". Optional.
      Returns:
      restartTries

    • setRestartTries

      public void setRestartTries(Integer restartTries)

    • rootfs

      public SpecGenerator rootfs(String rootfs)

    • getRootfs

      @Nullable public String getRootfs()
      Rootfs is the path to a directory that will be used as the container's root filesystem. No modification will be made to the directory, it will be directly mounted into the container as root. Conflicts with Image. At least one of Image or Rootfs must be specified.
      Returns:
      rootfs

    • setRootfs

      public void setRootfs(String rootfs)

    • rootfsMapping

      public SpecGenerator rootfsMapping(String rootfsMapping)

    • getRootfsMapping

      @Nullable public String getRootfsMapping()
      RootfsMapping specifies if there are UID/GID mappings to apply to the rootfs. Optional.
      Returns:
      rootfsMapping

    • setRootfsMapping

      public void setRootfsMapping(String rootfsMapping)

    • rootfsOverlay

      public SpecGenerator rootfsOverlay(Boolean rootfsOverlay)

    • getRootfsOverlay

      @Nullable public Boolean getRootfsOverlay()
      RootfsOverlay tells if rootfs is actually an overlay on top of base path. Optional.
      Returns:
      rootfsOverlay

    • setRootfsOverlay

      public void setRootfsOverlay(Boolean rootfsOverlay)

    • rootfsPropagation

      public SpecGenerator rootfsPropagation(String rootfsPropagation)

    • getRootfsPropagation

      @Nullable public String getRootfsPropagation()
      RootfsPropagation is the rootfs propagation mode for the container. If not set, the default of rslave will be used. Optional.
      Returns:
      rootfsPropagation

    • setRootfsPropagation

      public void setRootfsPropagation(String rootfsPropagation)

    • sdnotifyMode

      public SpecGenerator sdnotifyMode(String sdnotifyMode)

    • getSdnotifyMode

      @Nullable public String getSdnotifyMode()
      Determine how to handle the NOTIFY_SOCKET - do we participate or pass it through \"container\" - let the OCI runtime deal with it, advertise conmon's MAINPID \"conmon-only\" - advertise conmon's MAINPID, send READY when started, don't pass to OCI \"ignore\" - unset NOTIFY_SOCKET Optional.
      Returns:
      sdnotifyMode

    • setSdnotifyMode

      public void setSdnotifyMode(String sdnotifyMode)

    • seccompPolicy

      public SpecGenerator seccompPolicy(String seccompPolicy)

    • getSeccompPolicy

      @Nullable public String getSeccompPolicy()
      SeccompPolicy determines which seccomp profile gets applied the container. valid values: empty,default,image
      Returns:
      seccompPolicy

    • setSeccompPolicy

      public void setSeccompPolicy(String seccompPolicy)

    • seccompProfilePath

      public SpecGenerator seccompProfilePath(String seccompProfilePath)

    • getSeccompProfilePath

      @Nullable public String getSeccompProfilePath()
      SeccompProfilePath is the path to a JSON file containing the container's Seccomp profile. If not specified, no Seccomp profile will be used. Optional.
      Returns:
      seccompProfilePath

    • setSeccompProfilePath

      public void setSeccompProfilePath(String seccompProfilePath)

    • secretEnv

      public SpecGenerator secretEnv(Map<String,String> secretEnv)

    • putSecretEnvItem

      public SpecGenerator putSecretEnvItem(String key, String secretEnvItem)

    • getSecretEnv

      @Nullable public Map<String,String> getSecretEnv()
      EnvSecrets are secrets that will be set as environment variables Optional.
      Returns:
      secretEnv

    • setSecretEnv

      public void setSecretEnv(Map<String,String> secretEnv)

    • secrets

      public SpecGenerator secrets(List<@Valid Secret> secrets)

    • addSecretsItem

      public SpecGenerator addSecretsItem(Secret secretsItem)

    • getSecrets

      @Nullable @Valid public @Valid List<@Valid Secret> getSecrets()
      Secrets are the secrets that will be added to the container Optional.
      Returns:
      secrets

    • setSecrets

      public void setSecrets(List<@Valid Secret> secrets)

    • selinuxOpts

      public SpecGenerator selinuxOpts(List<String> selinuxOpts)

    • addSelinuxOptsItem

      public SpecGenerator addSelinuxOptsItem(String selinuxOptsItem)

    • getSelinuxOpts

      @Nullable public List<String> getSelinuxOpts()
      SelinuxProcessLabel is the process label the container will use. If SELinux is enabled and this is not specified, a label will be automatically generated if not specified. Optional.
      Returns:
      selinuxOpts

    • setSelinuxOpts

      public void setSelinuxOpts(List<String> selinuxOpts)

    • shmSize

      public SpecGenerator shmSize(Long shmSize)

    • getShmSize

      @Nullable public Long getShmSize()
      ShmSize is the size of the tmpfs to mount in at /dev/shm, in bytes. Conflicts with ShmSize if IpcNS is not private. Optional.
      Returns:
      shmSize

    • setShmSize

      public void setShmSize(Long shmSize)

    • shmSizeSystemd

      public SpecGenerator shmSizeSystemd(Long shmSizeSystemd)

    • getShmSizeSystemd

      @Nullable public Long getShmSizeSystemd()
      ShmSizeSystemd is the size of systemd-specific tmpfs mounts specifically /run, /run/lock, /var/log/journal and /tmp. Optional
      Returns:
      shmSizeSystemd

    • setShmSizeSystemd

      public void setShmSizeSystemd(Long shmSizeSystemd)

    • startupHealthConfig

      public SpecGenerator startupHealthConfig(StartupHealthCheck startupHealthConfig)

    • getStartupHealthConfig

      @Nullable @Valid public @Valid StartupHealthCheck getStartupHealthConfig()
      Get startupHealthConfig
      Returns:
      startupHealthConfig

    • setStartupHealthConfig

      public void setStartupHealthConfig(StartupHealthCheck startupHealthConfig)

    • stdin

      public SpecGenerator stdin(Boolean stdin)

    • getStdin

      @Nullable public Boolean getStdin()
      Stdin is whether the container will keep its STDIN open. Optional.
      Returns:
      stdin

    • setStdin

      public void setStdin(Boolean stdin)

    • stopSignal

      public SpecGenerator stopSignal(Long stopSignal)

    • getStopSignal

      @Nullable public Long getStopSignal()
      It implements the [os.Signal] interface.
      Returns:
      stopSignal

    • setStopSignal

      public void setStopSignal(Long stopSignal)

    • stopTimeout

      public SpecGenerator stopTimeout(Integer stopTimeout)

    • getStopTimeout

      @Nullable public Integer getStopTimeout()
      StopTimeout is a timeout between the container's stop signal being sent and SIGKILL being sent. If not provided, the default will be used. If 0 is used, stop signal will not be sent, and SIGKILL will be sent instead. Optional.
      Returns:
      stopTimeout

    • setStopTimeout

      public void setStopTimeout(Integer stopTimeout)

    • storageOpts

      public SpecGenerator storageOpts(Map<String,String> storageOpts)

    • putStorageOptsItem

      public SpecGenerator putStorageOptsItem(String key, String storageOptsItem)

    • getStorageOpts

      @Nullable public Map<String,String> getStorageOpts()
      StorageOpts is the container's storage options Optional.
      Returns:
      storageOpts

    • setStorageOpts

      public void setStorageOpts(Map<String,String> storageOpts)

    • sysctl

      public SpecGenerator sysctl(Map<String,String> sysctl)

    • putSysctlItem

      public SpecGenerator putSysctlItem(String key, String sysctlItem)

    • getSysctl

      @Nullable public Map<String,String> getSysctl()
      Sysctl sets kernel parameters for the container
      Returns:
      sysctl

    • setSysctl

      public void setSysctl(Map<String,String> sysctl)

    • systemd

      public SpecGenerator systemd(String systemd)

    • getSystemd

      @Nullable public String getSystemd()
      Systemd is whether the container will be started in systemd mode. Valid options are \"true\", \"false\", and \"always\". \"true\" enables this mode only if the binary run in the container is sbin/init or systemd. \"always\" unconditionally enables systemd mode. \"false\" unconditionally disables systemd mode. If enabled, mounts and stop signal will be modified. If set to \"always\" or set to \"true\" and conditionally triggered, conflicts with StopSignal. If not specified, \"false\" will be assumed. Optional.
      Returns:
      systemd

    • setSystemd

      public void setSystemd(String systemd)

    • terminal

      public SpecGenerator terminal(Boolean terminal)

    • getTerminal

      @Nullable public Boolean getTerminal()
      Terminal is whether the container will create a PTY. Optional.
      Returns:
      terminal

    • setTerminal

      public void setTerminal(Boolean terminal)

    • throttleReadBpsDevice

      public SpecGenerator throttleReadBpsDevice(Map<String,LinuxThrottleDevice> throttleReadBpsDevice)

    • putThrottleReadBpsDeviceItem

      public SpecGenerator putThrottleReadBpsDeviceItem(String key, LinuxThrottleDevice throttleReadBpsDeviceItem)

    • getThrottleReadBpsDevice

      @Nullable @Valid public @Valid Map<String,LinuxThrottleDevice> getThrottleReadBpsDevice()
      IO read rate limit per cgroup per device, bytes per second
      Returns:
      throttleReadBpsDevice

    • setThrottleReadBpsDevice

      public void setThrottleReadBpsDevice(Map<String,LinuxThrottleDevice> throttleReadBpsDevice)

    • throttleReadIOPSDevice

      public SpecGenerator throttleReadIOPSDevice(Map<String,LinuxThrottleDevice> throttleReadIOPSDevice)

    • putThrottleReadIOPSDeviceItem

      public SpecGenerator putThrottleReadIOPSDeviceItem(String key, LinuxThrottleDevice throttleReadIOPSDeviceItem)

    • getThrottleReadIOPSDevice

      @Nullable @Valid public @Valid Map<String,LinuxThrottleDevice> getThrottleReadIOPSDevice()
      IO read rate limit per cgroup per device, IO per second
      Returns:
      throttleReadIOPSDevice

    • setThrottleReadIOPSDevice

      public void setThrottleReadIOPSDevice(Map<String,LinuxThrottleDevice> throttleReadIOPSDevice)

    • throttleWriteBpsDevice

      public SpecGenerator throttleWriteBpsDevice(Map<String,LinuxThrottleDevice> throttleWriteBpsDevice)

    • putThrottleWriteBpsDeviceItem

      public SpecGenerator putThrottleWriteBpsDeviceItem(String key, LinuxThrottleDevice throttleWriteBpsDeviceItem)

    • getThrottleWriteBpsDevice

      @Nullable @Valid public @Valid Map<String,LinuxThrottleDevice> getThrottleWriteBpsDevice()
      IO write rate limit per cgroup per device, bytes per second
      Returns:
      throttleWriteBpsDevice

    • setThrottleWriteBpsDevice

      public void setThrottleWriteBpsDevice(Map<String,LinuxThrottleDevice> throttleWriteBpsDevice)

    • throttleWriteIOPSDevice

      public SpecGenerator throttleWriteIOPSDevice(Map<String,LinuxThrottleDevice> throttleWriteIOPSDevice)

    • putThrottleWriteIOPSDeviceItem

      public SpecGenerator putThrottleWriteIOPSDeviceItem(String key, LinuxThrottleDevice throttleWriteIOPSDeviceItem)

    • getThrottleWriteIOPSDevice

      @Nullable @Valid public @Valid Map<String,LinuxThrottleDevice> getThrottleWriteIOPSDevice()
      IO write rate limit per cgroup per device, IO per second
      Returns:
      throttleWriteIOPSDevice

    • setThrottleWriteIOPSDevice

      public void setThrottleWriteIOPSDevice(Map<String,LinuxThrottleDevice> throttleWriteIOPSDevice)

    • timeout

      public SpecGenerator timeout(Integer timeout)

    • getTimeout

      @Nullable public Integer getTimeout()
      Timeout is a maximum time in seconds the container will run before main process is sent SIGKILL. If 0 is used, signal will not be sent. Container can run indefinitely if they do not stop after the default termination signal. Optional.
      Returns:
      timeout

    • setTimeout

      public void setTimeout(Integer timeout)

    • timezone

      public SpecGenerator timezone(String timezone)

    • getTimezone

      @Nullable public String getTimezone()
      Timezone is the timezone inside the container. Local means it has the same timezone as the host machine Optional.
      Returns:
      timezone

    • setTimezone

      public void setTimezone(String timezone)

    • umask

      public SpecGenerator umask(String umask)

    • getUmask

      @Nullable public String getUmask()
      Umask is the umask the init process of the container will be run with.
      Returns:
      umask

    • setUmask

      public void setUmask(String umask)

    • unified

      public SpecGenerator unified(Map<String,String> unified)

    • putUnifiedItem

      public SpecGenerator putUnifiedItem(String key, String unifiedItem)

    • getUnified

      @Nullable public Map<String,String> getUnified()
      CgroupConf are key-value options passed into the container runtime that are used to configure cgroup v2. Optional.
      Returns:
      unified

    • setUnified

      public void setUnified(Map<String,String> unified)

    • unmask

      public SpecGenerator unmask(List<String> unmask)

    • addUnmaskItem

      public SpecGenerator addUnmaskItem(String unmaskItem)

    • getUnmask

      @Nullable public List<String> getUnmask()
      Unmask a path in the container. Some paths are masked by default, preventing them from being accessed within the container; this undoes that masking. If ALL is passed, all paths will be unmasked. Optional.
      Returns:
      unmask

    • setUnmask

      public void setUnmask(List<String> unmask)

    • unsetenv

      public SpecGenerator unsetenv(List<String> unsetenv)

    • addUnsetenvItem

      public SpecGenerator addUnsetenvItem(String unsetenvItem)

    • getUnsetenv

      @Nullable public List<String> getUnsetenv()
      UnsetEnv unsets the specified default environment variables from the image or from built-in or containers.conf Optional.
      Returns:
      unsetenv

    • setUnsetenv

      public void setUnsetenv(List<String> unsetenv)

    • unsetenvall

      public SpecGenerator unsetenvall(Boolean unsetenvall)

    • getUnsetenvall

      @Nullable public Boolean getUnsetenvall()
      UnsetEnvAll unsetall default environment variables from the image or from built-in or containers.conf UnsetEnvAll unsets all default environment variables from the image or from built-in Optional.
      Returns:
      unsetenvall

    • setUnsetenvall

      public void setUnsetenvall(Boolean unsetenvall)

    • useImageHosts

      public SpecGenerator useImageHosts(Boolean useImageHosts)

    • getUseImageHosts

      @Nullable public Boolean getUseImageHosts()
      UseImageHosts indicates that /etc/hosts should not be managed by Podman, and instead sourced from the image. Conflicts with HostAdd. Optional.
      Returns:
      useImageHosts

    • setUseImageHosts

      public void setUseImageHosts(Boolean useImageHosts)

    • useImageResolveConf

      public SpecGenerator useImageResolveConf(Boolean useImageResolveConf)

    • getUseImageResolveConf

      @Nullable public Boolean getUseImageResolveConf()
      UseImageResolvConf indicates that resolv.conf should not be managed by Podman, but instead sourced from the image. Conflicts with DNSServer, DNSSearch, DNSOption. Optional.
      Returns:
      useImageResolveConf

    • setUseImageResolveConf

      public void setUseImageResolveConf(Boolean useImageResolveConf)

    • user

      public SpecGenerator user(String user)

    • getUser

      @Nullable public String getUser()
      User is the user the container will be run as. Can be given as a UID or a username; if a username, it will be resolved within the container, using the container's /etc/passwd. If unset, the container will be run as root. Optional.
      Returns:
      user

    • setUser

      public void setUser(String user)

    • userns

      public SpecGenerator userns(Namespace userns)

    • getUserns

      @Nullable @Valid public @Valid Namespace getUserns()
      Get userns
      Returns:
      userns

    • setUserns

      public void setUserns(Namespace userns)

    • utsns

      public SpecGenerator utsns(Namespace utsns)

    • getUtsns

      @Nullable @Valid public @Valid Namespace getUtsns()
      Get utsns
      Returns:
      utsns

    • setUtsns

      public void setUtsns(Namespace utsns)

    • _volatile

      public SpecGenerator _volatile(Boolean _volatile)

    • getVolatile

      @Nullable public Boolean getVolatile()
      Volatile specifies whether the container storage can be optimized at the cost of not syncing all the dirty files in memory. Optional.
      Returns:
      _volatile

    • setVolatile

      public void setVolatile(Boolean _volatile)

    • volumes

      public SpecGenerator volumes(List<@Valid NamedVolume> volumes)

    • addVolumesItem

      public SpecGenerator addVolumesItem(NamedVolume volumesItem)

    • getVolumes

      @Nullable @Valid public @Valid List<@Valid NamedVolume> getVolumes()
      Volumes are named volumes that will be added to the container. These will supersede Image Volumes and VolumesFrom volumes where there are conflicts. Optional.
      Returns:
      volumes

    • setVolumes

      public void setVolumes(List<@Valid NamedVolume> volumes)

    • volumesFrom

      public SpecGenerator volumesFrom(List<String> volumesFrom)

    • addVolumesFromItem

      public SpecGenerator addVolumesFromItem(String volumesFromItem)

    • getVolumesFrom

      @Nullable public List<String> getVolumesFrom()
      VolumesFrom is a set of containers whose volumes will be added to this container. The name or ID of the container must be provided, and may optionally be followed by a : and then one or more comma-separated options. Valid options are 'ro', 'rw', and 'z'. Options will be used for all volumes sourced from the container. Optional.
      Returns:
      volumesFrom

    • setVolumesFrom

      public void setVolumesFrom(List<String> volumesFrom)

    • weightDevice

      public SpecGenerator weightDevice(Map<String,LinuxWeightDevice> weightDevice)

    • putWeightDeviceItem

      public SpecGenerator putWeightDeviceItem(String key, LinuxWeightDevice weightDeviceItem)

    • getWeightDevice

      @Nullable @Valid public @Valid Map<String,LinuxWeightDevice> getWeightDevice()
      Weight per cgroup per device, can override BlkioWeight
      Returns:
      weightDevice

    • setWeightDevice

      public void setWeightDevice(Map<String,LinuxWeightDevice> weightDevice)

    • workDir

      public SpecGenerator workDir(String workDir)

    • getWorkDir

      @Nullable public String getWorkDir()
      WorkDir is the container's working directory. If unset, the default, /, will be used. Optional.
      Returns:
      workDir

    • setWorkDir

      public void setWorkDir(String workDir)

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toJson

      public String toJson()
      Convert an instance of SpecGenerator to an JSON string
      Returns:
      JSON string