java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.kubernetes.api.model.ContainerFluent<A>

Direct Known Subclasses:: ContainerBuilder, PodSpecFluent.ContainersNested, PodSpecFluent.InitContainersNested

public class ContainerFluent<A extends ContainerFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>

Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`ContainerFluent.EnvFromNested<N>`
`class`	`ContainerFluent.EnvNested<N>`
`class`	`ContainerFluent.LifecycleNested<N>`
`class`	`ContainerFluent.LivenessProbeNested<N>`
`class`	`ContainerFluent.PortsNested<N>`
`class`	`ContainerFluent.ReadinessProbeNested<N>`
`class`	`ContainerFluent.ResizePolicyNested<N>`
`class`	`ContainerFluent.ResourcesNested<N>`
`class`	`ContainerFluent.SecurityContextNested<N>`
`class`	`ContainerFluent.StartupProbeNested<N>`
`class`	`ContainerFluent.VolumeDevicesNested<N>`
`class`	`ContainerFluent.VolumeMountsNested<N>`

Field Summary
- Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
  _visitables, VISIT

Constructor Summary

Constructors
Constructor Description

ContainerFluent()

ContainerFluent(Container instance)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`A`	`addAllToArgs(Collection<String> items)`
`A`	`addAllToCommand(Collection<String> items)`
`A`	`addAllToEnv(Collection<EnvVar> items)`
`A`	`addAllToEnvFrom(Collection<EnvFromSource> items)`
`A`	`addAllToPorts(Collection<ContainerPort> items)`
`A`	`addAllToResizePolicy(Collection<ContainerResizePolicy> items)`
`A`	`addAllToVolumeDevices(Collection<VolumeDevice> items)`
`A`	`addAllToVolumeMounts(Collection<VolumeMount> items)`
`ContainerFluent.EnvNested<A>`	`addNewEnv()`
`ContainerFluent.EnvFromNested<A>`	`addNewEnvFrom()`
`ContainerFluent.EnvFromNested<A>`	`addNewEnvFromLike(EnvFromSource item)`
`ContainerFluent.EnvNested<A>`	`addNewEnvLike(EnvVar item)`
`ContainerFluent.PortsNested<A>`	`addNewPort()`
`A`	`addNewPort(Integer containerPort, String hostIP, Integer hostPort, String name, String protocol)`
`ContainerFluent.PortsNested<A>`	`addNewPortLike(ContainerPort item)`
`ContainerFluent.ResizePolicyNested<A>`	`addNewResizePolicy()`
`A`	`addNewResizePolicy(String resourceName, String restartPolicy)`
`ContainerFluent.ResizePolicyNested<A>`	`addNewResizePolicyLike(ContainerResizePolicy item)`
`ContainerFluent.VolumeDevicesNested<A>`	`addNewVolumeDevice()`
`A`	`addNewVolumeDevice(String devicePath, String name)`
`ContainerFluent.VolumeDevicesNested<A>`	`addNewVolumeDeviceLike(VolumeDevice item)`
`ContainerFluent.VolumeMountsNested<A>`	`addNewVolumeMount()`
`ContainerFluent.VolumeMountsNested<A>`	`addNewVolumeMountLike(VolumeMount item)`
`A`	`addToAdditionalProperties(String key, Object value)`
`A`	`addToAdditionalProperties(Map<String,Object> map)`
`A`	`addToArgs(int index, String item)`
`A`	`addToArgs(String... items)`
`A`	`addToCommand(int index, String item)`
`A`	`addToCommand(String... items)`
`A`	`addToEnv(int index, EnvVar item)`
`A`	`addToEnv(EnvVar... items)`
`A`	`addToEnvFrom(int index, EnvFromSource item)`
`A`	`addToEnvFrom(EnvFromSource... items)`
`A`	`addToPorts(int index, ContainerPort item)`
`A`	`addToPorts(ContainerPort... items)`
`A`	`addToResizePolicy(int index, ContainerResizePolicy item)`
`A`	`addToResizePolicy(ContainerResizePolicy... items)`
`A`	`addToVolumeDevices(int index, VolumeDevice item)`
`A`	`addToVolumeDevices(VolumeDevice... items)`
`A`	`addToVolumeMounts(int index, VolumeMount item)`
`A`	`addToVolumeMounts(VolumeMount... items)`
`List<EnvVar>`	`buildEnv()`
`EnvVar`	`buildEnv(int index)`
`List<EnvFromSource>`	`buildEnvFrom()`
`EnvFromSource`	`buildEnvFrom(int index)`
`EnvVar`	`buildFirstEnv()`
`EnvFromSource`	`buildFirstEnvFrom()`
`ContainerPort`	`buildFirstPort()`
`ContainerResizePolicy`	`buildFirstResizePolicy()`
`VolumeDevice`	`buildFirstVolumeDevice()`
`VolumeMount`	`buildFirstVolumeMount()`
`EnvVar`	`buildLastEnv()`
`EnvFromSource`	`buildLastEnvFrom()`
`ContainerPort`	`buildLastPort()`
`ContainerResizePolicy`	`buildLastResizePolicy()`
`VolumeDevice`	`buildLastVolumeDevice()`
`VolumeMount`	`buildLastVolumeMount()`
`Lifecycle`	`buildLifecycle()`
`Probe`	`buildLivenessProbe()`
`EnvVar`	`buildMatchingEnv(Predicate<EnvVarBuilder> predicate)`
`EnvFromSource`	`buildMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)`
`ContainerPort`	`buildMatchingPort(Predicate<ContainerPortBuilder> predicate)`
`ContainerResizePolicy`	`buildMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)`
`VolumeDevice`	`buildMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)`
`VolumeMount`	`buildMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)`
`ContainerPort`	`buildPort(int index)`
`List<ContainerPort>`	`buildPorts()`
`Probe`	`buildReadinessProbe()`
`List<ContainerResizePolicy>`	`buildResizePolicy()`
`ContainerResizePolicy`	`buildResizePolicy(int index)`
`ResourceRequirements`	`buildResources()`
`SecurityContext`	`buildSecurityContext()`
`Probe`	`buildStartupProbe()`
`VolumeDevice`	`buildVolumeDevice(int index)`
`List<VolumeDevice>`	`buildVolumeDevices()`
`VolumeMount`	`buildVolumeMount(int index)`
`List<VolumeMount>`	`buildVolumeMounts()`
`protected void`	`copyInstance(Container instance)`
`ContainerFluent.EnvNested<A>`	`editEnv(int index)`
`ContainerFluent.EnvFromNested<A>`	`editEnvFrom(int index)`
`ContainerFluent.EnvNested<A>`	`editFirstEnv()`
`ContainerFluent.EnvFromNested<A>`	`editFirstEnvFrom()`
`ContainerFluent.PortsNested<A>`	`editFirstPort()`
`ContainerFluent.ResizePolicyNested<A>`	`editFirstResizePolicy()`
`ContainerFluent.VolumeDevicesNested<A>`	`editFirstVolumeDevice()`
`ContainerFluent.VolumeMountsNested<A>`	`editFirstVolumeMount()`
`ContainerFluent.EnvNested<A>`	`editLastEnv()`
`ContainerFluent.EnvFromNested<A>`	`editLastEnvFrom()`
`ContainerFluent.PortsNested<A>`	`editLastPort()`
`ContainerFluent.ResizePolicyNested<A>`	`editLastResizePolicy()`
`ContainerFluent.VolumeDevicesNested<A>`	`editLastVolumeDevice()`
`ContainerFluent.VolumeMountsNested<A>`	`editLastVolumeMount()`
`ContainerFluent.LifecycleNested<A>`	`editLifecycle()`
`ContainerFluent.LivenessProbeNested<A>`	`editLivenessProbe()`
`ContainerFluent.EnvNested<A>`	`editMatchingEnv(Predicate<EnvVarBuilder> predicate)`
`ContainerFluent.EnvFromNested<A>`	`editMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)`
`ContainerFluent.PortsNested<A>`	`editMatchingPort(Predicate<ContainerPortBuilder> predicate)`
`ContainerFluent.ResizePolicyNested<A>`	`editMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)`
`ContainerFluent.VolumeDevicesNested<A>`	`editMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)`
`ContainerFluent.VolumeMountsNested<A>`	`editMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)`
`ContainerFluent.LifecycleNested<A>`	`editOrNewLifecycle()`
`ContainerFluent.LifecycleNested<A>`	`editOrNewLifecycleLike(Lifecycle item)`
`ContainerFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbe()`
`ContainerFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbeLike(Probe item)`
`ContainerFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbe()`
`ContainerFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbeLike(Probe item)`
`ContainerFluent.ResourcesNested<A>`	`editOrNewResources()`
`ContainerFluent.ResourcesNested<A>`	`editOrNewResourcesLike(ResourceRequirements item)`
`ContainerFluent.SecurityContextNested<A>`	`editOrNewSecurityContext()`
`ContainerFluent.SecurityContextNested<A>`	`editOrNewSecurityContextLike(SecurityContext item)`
`ContainerFluent.StartupProbeNested<A>`	`editOrNewStartupProbe()`
`ContainerFluent.StartupProbeNested<A>`	`editOrNewStartupProbeLike(Probe item)`
`ContainerFluent.PortsNested<A>`	`editPort(int index)`
`ContainerFluent.ReadinessProbeNested<A>`	`editReadinessProbe()`
`ContainerFluent.ResizePolicyNested<A>`	`editResizePolicy(int index)`
`ContainerFluent.ResourcesNested<A>`	`editResources()`
`ContainerFluent.SecurityContextNested<A>`	`editSecurityContext()`
`ContainerFluent.StartupProbeNested<A>`	`editStartupProbe()`
`ContainerFluent.VolumeDevicesNested<A>`	`editVolumeDevice(int index)`
`ContainerFluent.VolumeMountsNested<A>`	`editVolumeMount(int index)`
`boolean`	`equals(Object o)`
`Map<String,Object>`	`getAdditionalProperties()`
`String`	`getArg(int index)`
`List<String>`	`getArgs()`
`List<String>`	`getCommand()`
`String`	`getCommand(int index)`
`String`	`getFirstArg()`
`String`	`getFirstCommand()`
`String`	`getImage()`
`String`	`getImagePullPolicy()`
`String`	`getLastArg()`
`String`	`getLastCommand()`
`String`	`getMatchingArg(Predicate<String> predicate)`
`String`	`getMatchingCommand(Predicate<String> predicate)`
`String`	`getName()`
`String`	`getRestartPolicy()`
`Boolean`	`getStdin()`
`Boolean`	`getStdinOnce()`
`String`	`getTerminationMessagePath()`
`String`	`getTerminationMessagePolicy()`
`Boolean`	`getTty()`
`String`	`getWorkingDir()`
`boolean`	`hasAdditionalProperties()`
`boolean`	`hasArgs()`
`boolean`	`hasCommand()`
`boolean`	`hasEnv()`
`boolean`	`hasEnvFrom()`
`int`	`hashCode()`
`boolean`	`hasImage()`
`boolean`	`hasImagePullPolicy()`
`boolean`	`hasLifecycle()`
`boolean`	`hasLivenessProbe()`
`boolean`	`hasMatchingArg(Predicate<String> predicate)`
`boolean`	`hasMatchingCommand(Predicate<String> predicate)`
`boolean`	`hasMatchingEnv(Predicate<EnvVarBuilder> predicate)`
`boolean`	`hasMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)`
`boolean`	`hasMatchingPort(Predicate<ContainerPortBuilder> predicate)`
`boolean`	`hasMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)`
`boolean`	`hasMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)`
`boolean`	`hasMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)`
`boolean`	`hasName()`
`boolean`	`hasPorts()`
`boolean`	`hasReadinessProbe()`
`boolean`	`hasResizePolicy()`
`boolean`	`hasResources()`
`boolean`	`hasRestartPolicy()`
`boolean`	`hasSecurityContext()`
`boolean`	`hasStartupProbe()`
`boolean`	`hasStdin()`
`boolean`	`hasStdinOnce()`
`boolean`	`hasTerminationMessagePath()`
`boolean`	`hasTerminationMessagePolicy()`
`boolean`	`hasTty()`
`boolean`	`hasVolumeDevices()`
`boolean`	`hasVolumeMounts()`
`boolean`	`hasWorkingDir()`
`A`	`removeAllFromArgs(Collection<String> items)`
`A`	`removeAllFromCommand(Collection<String> items)`
`A`	`removeAllFromEnv(Collection<EnvVar> items)`
`A`	`removeAllFromEnvFrom(Collection<EnvFromSource> items)`
`A`	`removeAllFromPorts(Collection<ContainerPort> items)`
`A`	`removeAllFromResizePolicy(Collection<ContainerResizePolicy> items)`
`A`	`removeAllFromVolumeDevices(Collection<VolumeDevice> items)`
`A`	`removeAllFromVolumeMounts(Collection<VolumeMount> items)`
`A`	`removeFromAdditionalProperties(String key)`
`A`	`removeFromAdditionalProperties(Map<String,Object> map)`
`A`	`removeFromArgs(String... items)`
`A`	`removeFromCommand(String... items)`
`A`	`removeFromEnv(EnvVar... items)`
`A`	`removeFromEnvFrom(EnvFromSource... items)`
`A`	`removeFromPorts(ContainerPort... items)`
`A`	`removeFromResizePolicy(ContainerResizePolicy... items)`
`A`	`removeFromVolumeDevices(VolumeDevice... items)`
`A`	`removeFromVolumeMounts(VolumeMount... items)`
`A`	`removeMatchingFromEnv(Predicate<EnvVarBuilder> predicate)`
`A`	`removeMatchingFromEnvFrom(Predicate<EnvFromSourceBuilder> predicate)`
`A`	`removeMatchingFromPorts(Predicate<ContainerPortBuilder> predicate)`
`A`	`removeMatchingFromResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)`
`A`	`removeMatchingFromVolumeDevices(Predicate<VolumeDeviceBuilder> predicate)`
`A`	`removeMatchingFromVolumeMounts(Predicate<VolumeMountBuilder> predicate)`
`ContainerFluent.EnvFromNested<A>`	`setNewEnvFromLike(int index, EnvFromSource item)`
`ContainerFluent.EnvNested<A>`	`setNewEnvLike(int index, EnvVar item)`
`ContainerFluent.PortsNested<A>`	`setNewPortLike(int index, ContainerPort item)`
`ContainerFluent.ResizePolicyNested<A>`	`setNewResizePolicyLike(int index, ContainerResizePolicy item)`
`ContainerFluent.VolumeDevicesNested<A>`	`setNewVolumeDeviceLike(int index, VolumeDevice item)`
`ContainerFluent.VolumeMountsNested<A>`	`setNewVolumeMountLike(int index, VolumeMount item)`
`A`	`setToArgs(int index, String item)`
`A`	`setToCommand(int index, String item)`
`A`	`setToEnv(int index, EnvVar item)`
`A`	`setToEnvFrom(int index, EnvFromSource item)`
`A`	`setToPorts(int index, ContainerPort item)`
`A`	`setToResizePolicy(int index, ContainerResizePolicy item)`
`A`	`setToVolumeDevices(int index, VolumeDevice item)`
`A`	`setToVolumeMounts(int index, VolumeMount item)`
`String`	`toString()`
`<K,V> A`	`withAdditionalProperties(Map<String,Object> additionalProperties)`
`A`	`withArgs(String... args)`
`A`	`withArgs(List<String> args)`
`A`	`withCommand(String... command)`
`A`	`withCommand(List<String> command)`
`A`	`withEnv(EnvVar... env)`
`A`	`withEnv(List<EnvVar> env)`
`A`	`withEnvFrom(EnvFromSource... envFrom)`
`A`	`withEnvFrom(List<EnvFromSource> envFrom)`
`A`	`withImage(String image)`
`A`	`withImagePullPolicy(String imagePullPolicy)`
`A`	`withLifecycle(Lifecycle lifecycle)`
`A`	`withLivenessProbe(Probe livenessProbe)`
`A`	`withName(String name)`
`ContainerFluent.LifecycleNested<A>`	`withNewLifecycle()`
`ContainerFluent.LifecycleNested<A>`	`withNewLifecycleLike(Lifecycle item)`
`ContainerFluent.LivenessProbeNested<A>`	`withNewLivenessProbe()`
`ContainerFluent.LivenessProbeNested<A>`	`withNewLivenessProbeLike(Probe item)`
`ContainerFluent.ReadinessProbeNested<A>`	`withNewReadinessProbe()`
`ContainerFluent.ReadinessProbeNested<A>`	`withNewReadinessProbeLike(Probe item)`
`ContainerFluent.ResourcesNested<A>`	`withNewResources()`
`ContainerFluent.ResourcesNested<A>`	`withNewResourcesLike(ResourceRequirements item)`
`ContainerFluent.SecurityContextNested<A>`	`withNewSecurityContext()`
`ContainerFluent.SecurityContextNested<A>`	`withNewSecurityContextLike(SecurityContext item)`
`ContainerFluent.StartupProbeNested<A>`	`withNewStartupProbe()`
`ContainerFluent.StartupProbeNested<A>`	`withNewStartupProbeLike(Probe item)`
`A`	`withPorts(ContainerPort... ports)`
`A`	`withPorts(List<ContainerPort> ports)`
`A`	`withReadinessProbe(Probe readinessProbe)`
`A`	`withResizePolicy(ContainerResizePolicy... resizePolicy)`
`A`	`withResizePolicy(List<ContainerResizePolicy> resizePolicy)`
`A`	`withResources(ResourceRequirements resources)`
`A`	`withRestartPolicy(String restartPolicy)`
`A`	`withSecurityContext(SecurityContext securityContext)`
`A`	`withStartupProbe(Probe startupProbe)`
`A`	`withStdin()`
`A`	`withStdin(Boolean stdin)`
`A`	`withStdinOnce()`
`A`	`withStdinOnce(Boolean stdinOnce)`
`A`	`withTerminationMessagePath(String terminationMessagePath)`
`A`	`withTerminationMessagePolicy(String terminationMessagePolicy)`
`A`	`withTty()`
`A`	`withTty(Boolean tty)`
`A`	`withVolumeDevices(VolumeDevice... volumeDevices)`
`A`	`withVolumeDevices(List<VolumeDevice> volumeDevices)`
`A`	`withVolumeMounts(VolumeMount... volumeMounts)`
`A`	`withVolumeMounts(List<VolumeMount> volumeMounts)`
`A`	`withWorkingDir(String workingDir)`

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent
aggregate, aggregate, build, build, builderOf, getVisitableMap

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ContainerFluent
```
public ContainerFluent()
```

ContainerFluent

public ContainerFluent(Container instance)

Method Detail

copyInstance

protected void copyInstance(Container instance)

addToArgs

public A addToArgs(int index,
                   String item)

setToArgs

public A setToArgs(int index,
                   String item)

addToArgs

public A addToArgs(String... items)

addAllToArgs

public A addAllToArgs(Collection<String> items)

removeFromArgs

public A removeFromArgs(String... items)

removeAllFromArgs

public A removeAllFromArgs(Collection<String> items)

getArgs
```
public List<String> getArgs()
```

getArg
```
public String getArg(int index)
```

getFirstArg
```
public String getFirstArg()
```

getLastArg
```
public String getLastArg()
```

getMatchingArg

public String getMatchingArg(Predicate<String> predicate)

hasMatchingArg

public boolean hasMatchingArg(Predicate<String> predicate)

withArgs

public A withArgs(List<String> args)

withArgs
```
public A withArgs(String... args)
```

hasArgs
```
public boolean hasArgs()
```

addToCommand

public A addToCommand(int index,
                      String item)

setToCommand

public A setToCommand(int index,
                      String item)

addToCommand

public A addToCommand(String... items)

addAllToCommand

public A addAllToCommand(Collection<String> items)

removeFromCommand

public A removeFromCommand(String... items)

removeAllFromCommand

public A removeAllFromCommand(Collection<String> items)

getCommand
```
public List<String> getCommand()
```

getCommand

public String getCommand(int index)

getFirstCommand
```
public String getFirstCommand()
```

getLastCommand
```
public String getLastCommand()
```

getMatchingCommand

public String getMatchingCommand(Predicate<String> predicate)

hasMatchingCommand

public boolean hasMatchingCommand(Predicate<String> predicate)

withCommand

public A withCommand(List<String> command)

withCommand

public A withCommand(String... command)

hasCommand
```
public boolean hasCommand()
```

addToEnv

public A addToEnv(int index,
                  EnvVar item)

setToEnv

public A setToEnv(int index,
                  EnvVar item)

addToEnv

public A addToEnv(EnvVar... items)

addAllToEnv

public A addAllToEnv(Collection<EnvVar> items)

removeFromEnv

public A removeFromEnv(EnvVar... items)

removeAllFromEnv

public A removeAllFromEnv(Collection<EnvVar> items)

removeMatchingFromEnv

public A removeMatchingFromEnv(Predicate<EnvVarBuilder> predicate)

buildEnv
```
public List<EnvVar> buildEnv()
```

buildEnv
```
public EnvVar buildEnv(int index)
```

buildFirstEnv
```
public EnvVar buildFirstEnv()
```

buildLastEnv
```
public EnvVar buildLastEnv()
```

buildMatchingEnv

public EnvVar buildMatchingEnv(Predicate<EnvVarBuilder> predicate)

hasMatchingEnv

public boolean hasMatchingEnv(Predicate<EnvVarBuilder> predicate)

withEnv

public A withEnv(List<EnvVar> env)

withEnv
```
public A withEnv(EnvVar... env)
```

hasEnv
```
public boolean hasEnv()
```

addNewEnv

public ContainerFluent.EnvNested<A> addNewEnv()

addNewEnvLike

public ContainerFluent.EnvNested<A> addNewEnvLike(EnvVar item)

setNewEnvLike

public ContainerFluent.EnvNested<A> setNewEnvLike(int index,
                                                  EnvVar item)

editEnv

public ContainerFluent.EnvNested<A> editEnv(int index)

editFirstEnv

public ContainerFluent.EnvNested<A> editFirstEnv()

editLastEnv

public ContainerFluent.EnvNested<A> editLastEnv()

editMatchingEnv

public ContainerFluent.EnvNested<A> editMatchingEnv(Predicate<EnvVarBuilder> predicate)

addToEnvFrom

public A addToEnvFrom(int index,
                      EnvFromSource item)

setToEnvFrom

public A setToEnvFrom(int index,
                      EnvFromSource item)

addToEnvFrom

public A addToEnvFrom(EnvFromSource... items)

addAllToEnvFrom

public A addAllToEnvFrom(Collection<EnvFromSource> items)

removeFromEnvFrom

public A removeFromEnvFrom(EnvFromSource... items)

removeAllFromEnvFrom

public A removeAllFromEnvFrom(Collection<EnvFromSource> items)

removeMatchingFromEnvFrom

public A removeMatchingFromEnvFrom(Predicate<EnvFromSourceBuilder> predicate)

buildEnvFrom

public List<EnvFromSource> buildEnvFrom()

buildEnvFrom

public EnvFromSource buildEnvFrom(int index)

buildFirstEnvFrom

public EnvFromSource buildFirstEnvFrom()

buildLastEnvFrom

public EnvFromSource buildLastEnvFrom()

buildMatchingEnvFrom

public EnvFromSource buildMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)

hasMatchingEnvFrom

public boolean hasMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)

withEnvFrom

public A withEnvFrom(List<EnvFromSource> envFrom)

withEnvFrom

public A withEnvFrom(EnvFromSource... envFrom)

hasEnvFrom
```
public boolean hasEnvFrom()
```

addNewEnvFrom

public ContainerFluent.EnvFromNested<A> addNewEnvFrom()

addNewEnvFromLike

public ContainerFluent.EnvFromNested<A> addNewEnvFromLike(EnvFromSource item)

setNewEnvFromLike

public ContainerFluent.EnvFromNested<A> setNewEnvFromLike(int index,
                                                          EnvFromSource item)

editEnvFrom

public ContainerFluent.EnvFromNested<A> editEnvFrom(int index)

editFirstEnvFrom

public ContainerFluent.EnvFromNested<A> editFirstEnvFrom()

editLastEnvFrom

public ContainerFluent.EnvFromNested<A> editLastEnvFrom()

editMatchingEnvFrom

public ContainerFluent.EnvFromNested<A> editMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)

getImage
```
public String getImage()
```

withImage
```
public A withImage(String image)
```

hasImage
```
public boolean hasImage()
```

getImagePullPolicy
```
public String getImagePullPolicy()
```

withImagePullPolicy

public A withImagePullPolicy(String imagePullPolicy)

hasImagePullPolicy
```
public boolean hasImagePullPolicy()
```

buildLifecycle
```
public Lifecycle buildLifecycle()
```

withLifecycle

public A withLifecycle(Lifecycle lifecycle)

hasLifecycle
```
public boolean hasLifecycle()
```

withNewLifecycle

public ContainerFluent.LifecycleNested<A> withNewLifecycle()

withNewLifecycleLike

public ContainerFluent.LifecycleNested<A> withNewLifecycleLike(Lifecycle item)

editLifecycle

public ContainerFluent.LifecycleNested<A> editLifecycle()

editOrNewLifecycle

public ContainerFluent.LifecycleNested<A> editOrNewLifecycle()

editOrNewLifecycleLike

public ContainerFluent.LifecycleNested<A> editOrNewLifecycleLike(Lifecycle item)

buildLivenessProbe
```
public Probe buildLivenessProbe()
```

withLivenessProbe

public A withLivenessProbe(Probe livenessProbe)

hasLivenessProbe
```
public boolean hasLivenessProbe()
```

withNewLivenessProbe

public ContainerFluent.LivenessProbeNested<A> withNewLivenessProbe()

withNewLivenessProbeLike

public ContainerFluent.LivenessProbeNested<A> withNewLivenessProbeLike(Probe item)

editLivenessProbe

public ContainerFluent.LivenessProbeNested<A> editLivenessProbe()

editOrNewLivenessProbe

public ContainerFluent.LivenessProbeNested<A> editOrNewLivenessProbe()

editOrNewLivenessProbeLike

public ContainerFluent.LivenessProbeNested<A> editOrNewLivenessProbeLike(Probe item)

getName
```
public String getName()
```

withName
```
public A withName(String name)
```

hasName
```
public boolean hasName()
```

addToPorts

public A addToPorts(int index,
                    ContainerPort item)

setToPorts

public A setToPorts(int index,
                    ContainerPort item)

addToPorts

public A addToPorts(ContainerPort... items)

addAllToPorts

public A addAllToPorts(Collection<ContainerPort> items)

removeFromPorts

public A removeFromPorts(ContainerPort... items)

removeAllFromPorts

public A removeAllFromPorts(Collection<ContainerPort> items)

removeMatchingFromPorts

public A removeMatchingFromPorts(Predicate<ContainerPortBuilder> predicate)

buildPorts

public List<ContainerPort> buildPorts()

buildPort

public ContainerPort buildPort(int index)

buildFirstPort
```
public ContainerPort buildFirstPort()
```

buildLastPort
```
public ContainerPort buildLastPort()
```

buildMatchingPort

public ContainerPort buildMatchingPort(Predicate<ContainerPortBuilder> predicate)

hasMatchingPort

public boolean hasMatchingPort(Predicate<ContainerPortBuilder> predicate)

withPorts

public A withPorts(List<ContainerPort> ports)

withPorts

public A withPorts(ContainerPort... ports)

hasPorts
```
public boolean hasPorts()
```

addNewPort

public A addNewPort(Integer containerPort,
                    String hostIP,
                    Integer hostPort,
                    String name,
                    String protocol)

addNewPort

public ContainerFluent.PortsNested<A> addNewPort()

addNewPortLike

public ContainerFluent.PortsNested<A> addNewPortLike(ContainerPort item)

setNewPortLike

public ContainerFluent.PortsNested<A> setNewPortLike(int index,
                                                     ContainerPort item)

editPort

public ContainerFluent.PortsNested<A> editPort(int index)

editFirstPort

public ContainerFluent.PortsNested<A> editFirstPort()

editLastPort

public ContainerFluent.PortsNested<A> editLastPort()

editMatchingPort

public ContainerFluent.PortsNested<A> editMatchingPort(Predicate<ContainerPortBuilder> predicate)

buildReadinessProbe
```
public Probe buildReadinessProbe()
```

withReadinessProbe

public A withReadinessProbe(Probe readinessProbe)

hasReadinessProbe
```
public boolean hasReadinessProbe()
```

withNewReadinessProbe

public ContainerFluent.ReadinessProbeNested<A> withNewReadinessProbe()

withNewReadinessProbeLike

public ContainerFluent.ReadinessProbeNested<A> withNewReadinessProbeLike(Probe item)

editReadinessProbe

public ContainerFluent.ReadinessProbeNested<A> editReadinessProbe()

editOrNewReadinessProbe

public ContainerFluent.ReadinessProbeNested<A> editOrNewReadinessProbe()

editOrNewReadinessProbeLike

public ContainerFluent.ReadinessProbeNested<A> editOrNewReadinessProbeLike(Probe item)

addToResizePolicy

public A addToResizePolicy(int index,
                           ContainerResizePolicy item)

setToResizePolicy

public A setToResizePolicy(int index,
                           ContainerResizePolicy item)

addToResizePolicy

public A addToResizePolicy(ContainerResizePolicy... items)

addAllToResizePolicy

public A addAllToResizePolicy(Collection<ContainerResizePolicy> items)

removeFromResizePolicy

public A removeFromResizePolicy(ContainerResizePolicy... items)

removeAllFromResizePolicy

public A removeAllFromResizePolicy(Collection<ContainerResizePolicy> items)

removeMatchingFromResizePolicy

public A removeMatchingFromResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)

buildResizePolicy

public List<ContainerResizePolicy> buildResizePolicy()

buildResizePolicy

public ContainerResizePolicy buildResizePolicy(int index)

buildFirstResizePolicy

public ContainerResizePolicy buildFirstResizePolicy()

buildLastResizePolicy

public ContainerResizePolicy buildLastResizePolicy()

buildMatchingResizePolicy

public ContainerResizePolicy buildMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)

hasMatchingResizePolicy

public boolean hasMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)

withResizePolicy

public A withResizePolicy(List<ContainerResizePolicy> resizePolicy)

withResizePolicy

public A withResizePolicy(ContainerResizePolicy... resizePolicy)

hasResizePolicy
```
public boolean hasResizePolicy()
```

addNewResizePolicy

public A addNewResizePolicy(String resourceName,
                            String restartPolicy)

addNewResizePolicy

public ContainerFluent.ResizePolicyNested<A> addNewResizePolicy()

addNewResizePolicyLike

public ContainerFluent.ResizePolicyNested<A> addNewResizePolicyLike(ContainerResizePolicy item)

setNewResizePolicyLike

public ContainerFluent.ResizePolicyNested<A> setNewResizePolicyLike(int index,
                                                                    ContainerResizePolicy item)

editResizePolicy

public ContainerFluent.ResizePolicyNested<A> editResizePolicy(int index)

editFirstResizePolicy

public ContainerFluent.ResizePolicyNested<A> editFirstResizePolicy()

editLastResizePolicy

public ContainerFluent.ResizePolicyNested<A> editLastResizePolicy()

editMatchingResizePolicy

public ContainerFluent.ResizePolicyNested<A> editMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)

buildResources

public ResourceRequirements buildResources()

withResources

public A withResources(ResourceRequirements resources)

hasResources
```
public boolean hasResources()
```

withNewResources

public ContainerFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

public ContainerFluent.ResourcesNested<A> withNewResourcesLike(ResourceRequirements item)

editResources

public ContainerFluent.ResourcesNested<A> editResources()

editOrNewResources

public ContainerFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public ContainerFluent.ResourcesNested<A> editOrNewResourcesLike(ResourceRequirements item)

getRestartPolicy
```
public String getRestartPolicy()
```

withRestartPolicy

public A withRestartPolicy(String restartPolicy)

hasRestartPolicy
```
public boolean hasRestartPolicy()
```

buildSecurityContext

public SecurityContext buildSecurityContext()

withSecurityContext

public A withSecurityContext(SecurityContext securityContext)

hasSecurityContext
```
public boolean hasSecurityContext()
```

withNewSecurityContext

public ContainerFluent.SecurityContextNested<A> withNewSecurityContext()

withNewSecurityContextLike

public ContainerFluent.SecurityContextNested<A> withNewSecurityContextLike(SecurityContext item)

editSecurityContext

public ContainerFluent.SecurityContextNested<A> editSecurityContext()

editOrNewSecurityContext

public ContainerFluent.SecurityContextNested<A> editOrNewSecurityContext()

editOrNewSecurityContextLike

public ContainerFluent.SecurityContextNested<A> editOrNewSecurityContextLike(SecurityContext item)

buildStartupProbe
```
public Probe buildStartupProbe()
```

withStartupProbe

public A withStartupProbe(Probe startupProbe)

hasStartupProbe
```
public boolean hasStartupProbe()
```

withNewStartupProbe

public ContainerFluent.StartupProbeNested<A> withNewStartupProbe()

withNewStartupProbeLike

public ContainerFluent.StartupProbeNested<A> withNewStartupProbeLike(Probe item)

editStartupProbe

public ContainerFluent.StartupProbeNested<A> editStartupProbe()

editOrNewStartupProbe

public ContainerFluent.StartupProbeNested<A> editOrNewStartupProbe()

editOrNewStartupProbeLike

public ContainerFluent.StartupProbeNested<A> editOrNewStartupProbeLike(Probe item)

getStdin
```
public Boolean getStdin()
```

withStdin
```
public A withStdin(Boolean stdin)
```

hasStdin
```
public boolean hasStdin()
```

getStdinOnce
```
public Boolean getStdinOnce()
```

withStdinOnce

public A withStdinOnce(Boolean stdinOnce)

hasStdinOnce
```
public boolean hasStdinOnce()
```

getTerminationMessagePath

public String getTerminationMessagePath()

withTerminationMessagePath

public A withTerminationMessagePath(String terminationMessagePath)

hasTerminationMessagePath

public boolean hasTerminationMessagePath()

getTerminationMessagePolicy

public String getTerminationMessagePolicy()

withTerminationMessagePolicy

public A withTerminationMessagePolicy(String terminationMessagePolicy)

hasTerminationMessagePolicy

public boolean hasTerminationMessagePolicy()

getTty
```
public Boolean getTty()
```

withTty
```
public A withTty(Boolean tty)
```

hasTty
```
public boolean hasTty()
```

addToVolumeDevices

public A addToVolumeDevices(int index,
                            VolumeDevice item)

setToVolumeDevices

public A setToVolumeDevices(int index,
                            VolumeDevice item)

addToVolumeDevices

public A addToVolumeDevices(VolumeDevice... items)

addAllToVolumeDevices

public A addAllToVolumeDevices(Collection<VolumeDevice> items)

removeFromVolumeDevices

public A removeFromVolumeDevices(VolumeDevice... items)

removeAllFromVolumeDevices

public A removeAllFromVolumeDevices(Collection<VolumeDevice> items)

removeMatchingFromVolumeDevices

public A removeMatchingFromVolumeDevices(Predicate<VolumeDeviceBuilder> predicate)

buildVolumeDevices

public List<VolumeDevice> buildVolumeDevices()

buildVolumeDevice

public VolumeDevice buildVolumeDevice(int index)

buildFirstVolumeDevice

public VolumeDevice buildFirstVolumeDevice()

buildLastVolumeDevice

public VolumeDevice buildLastVolumeDevice()

buildMatchingVolumeDevice

public VolumeDevice buildMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)

hasMatchingVolumeDevice

public boolean hasMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)

withVolumeDevices

public A withVolumeDevices(List<VolumeDevice> volumeDevices)

withVolumeDevices

public A withVolumeDevices(VolumeDevice... volumeDevices)

hasVolumeDevices
```
public boolean hasVolumeDevices()
```

addNewVolumeDevice

public A addNewVolumeDevice(String devicePath,
                            String name)

addNewVolumeDevice

public ContainerFluent.VolumeDevicesNested<A> addNewVolumeDevice()

addNewVolumeDeviceLike

public ContainerFluent.VolumeDevicesNested<A> addNewVolumeDeviceLike(VolumeDevice item)

setNewVolumeDeviceLike

public ContainerFluent.VolumeDevicesNested<A> setNewVolumeDeviceLike(int index,
                                                                     VolumeDevice item)

editVolumeDevice

public ContainerFluent.VolumeDevicesNested<A> editVolumeDevice(int index)

editFirstVolumeDevice

public ContainerFluent.VolumeDevicesNested<A> editFirstVolumeDevice()

editLastVolumeDevice

public ContainerFluent.VolumeDevicesNested<A> editLastVolumeDevice()

editMatchingVolumeDevice

public ContainerFluent.VolumeDevicesNested<A> editMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)

addToVolumeMounts

public A addToVolumeMounts(int index,
                           VolumeMount item)

setToVolumeMounts

public A setToVolumeMounts(int index,
                           VolumeMount item)

addToVolumeMounts

public A addToVolumeMounts(VolumeMount... items)

addAllToVolumeMounts

public A addAllToVolumeMounts(Collection<VolumeMount> items)

removeFromVolumeMounts

public A removeFromVolumeMounts(VolumeMount... items)

removeAllFromVolumeMounts

public A removeAllFromVolumeMounts(Collection<VolumeMount> items)

removeMatchingFromVolumeMounts

public A removeMatchingFromVolumeMounts(Predicate<VolumeMountBuilder> predicate)

buildVolumeMounts

public List<VolumeMount> buildVolumeMounts()

buildVolumeMount

public VolumeMount buildVolumeMount(int index)

buildFirstVolumeMount

public VolumeMount buildFirstVolumeMount()

buildLastVolumeMount

public VolumeMount buildLastVolumeMount()

buildMatchingVolumeMount

public VolumeMount buildMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)

hasMatchingVolumeMount

public boolean hasMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)

withVolumeMounts

public A withVolumeMounts(List<VolumeMount> volumeMounts)

withVolumeMounts

public A withVolumeMounts(VolumeMount... volumeMounts)

hasVolumeMounts
```
public boolean hasVolumeMounts()
```

addNewVolumeMount

public ContainerFluent.VolumeMountsNested<A> addNewVolumeMount()

addNewVolumeMountLike

public ContainerFluent.VolumeMountsNested<A> addNewVolumeMountLike(VolumeMount item)

setNewVolumeMountLike

public ContainerFluent.VolumeMountsNested<A> setNewVolumeMountLike(int index,
                                                                   VolumeMount item)

editVolumeMount

public ContainerFluent.VolumeMountsNested<A> editVolumeMount(int index)

editFirstVolumeMount

public ContainerFluent.VolumeMountsNested<A> editFirstVolumeMount()

editLastVolumeMount

public ContainerFluent.VolumeMountsNested<A> editLastVolumeMount()

editMatchingVolumeMount

public ContainerFluent.VolumeMountsNested<A> editMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)

getWorkingDir
```
public String getWorkingDir()
```

withWorkingDir

public A withWorkingDir(String workingDir)

hasWorkingDir
```
public boolean hasWorkingDir()
```

addToAdditionalProperties

public A addToAdditionalProperties(String key,
                                   Object value)

addToAdditionalProperties

public A addToAdditionalProperties(Map<String,Object> map)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(String key)

removeFromAdditionalProperties

public A removeFromAdditionalProperties(Map<String,Object> map)

getAdditionalProperties

public Map<String,Object> getAdditionalProperties()

withAdditionalProperties

public <K,V> A withAdditionalProperties(Map<String,Object> additionalProperties)

hasAdditionalProperties

public boolean hasAdditionalProperties()

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends ContainerFluent<A>>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class io.fabric8.kubernetes.api.builder.BaseFluent<A extends ContainerFluent<A>>

toString
```
public String toString()
```
Overrides:

toString in class Object

withStdin
```
public A withStdin()
```

withStdinOnce
```
public A withStdinOnce()
```

withTty
```
public A withTty()
```

Class ContainerFluent<A extends ContainerFluent<A>>

Nested Class Summary

Field Summary

Fields inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Constructor Summary

Method Summary

Methods inherited from class io.fabric8.kubernetes.api.builder.BaseFluent

Methods inherited from class java.lang.Object

Constructor Detail

ContainerFluent

ContainerFluent

Method Detail

copyInstance

addToArgs

setToArgs

addToArgs

addAllToArgs

removeFromArgs

removeAllFromArgs

getArgs

getArg

getFirstArg

getLastArg

getMatchingArg

hasMatchingArg

withArgs

withArgs

hasArgs

addToCommand

setToCommand

addToCommand

addAllToCommand

removeFromCommand

removeAllFromCommand

getCommand

getCommand

getFirstCommand

getLastCommand

getMatchingCommand

hasMatchingCommand

withCommand

withCommand

hasCommand

addToEnv

setToEnv

addToEnv

addAllToEnv

removeFromEnv

removeAllFromEnv

removeMatchingFromEnv

buildEnv

buildEnv

buildFirstEnv

buildLastEnv

buildMatchingEnv

hasMatchingEnv

withEnv

withEnv

hasEnv

addNewEnv

addNewEnvLike

setNewEnvLike

editEnv

editFirstEnv

editLastEnv

editMatchingEnv

addToEnvFrom

setToEnvFrom

addToEnvFrom

addAllToEnvFrom

removeFromEnvFrom

removeAllFromEnvFrom

removeMatchingFromEnvFrom

buildEnvFrom

buildEnvFrom

buildFirstEnvFrom

buildLastEnvFrom

buildMatchingEnvFrom

hasMatchingEnvFrom

withEnvFrom