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

Direct Known Subclasses:: EphemeralContainerBuilder, PodSpecFluent.EphemeralContainersNested

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

Generated

Nested Class Summary

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

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

Constructor Summary

Constructors
Constructor Description

EphemeralContainerFluent()

EphemeralContainerFluent(EphemeralContainer 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)`
`EphemeralContainerFluent.EnvNested<A>`	`addNewEnv()`
`EphemeralContainerFluent.EnvFromNested<A>`	`addNewEnvFrom()`
`EphemeralContainerFluent.EnvFromNested<A>`	`addNewEnvFromLike(EnvFromSource item)`
`EphemeralContainerFluent.EnvNested<A>`	`addNewEnvLike(EnvVar item)`
`EphemeralContainerFluent.PortsNested<A>`	`addNewPort()`
`A`	`addNewPort(Integer containerPort, String hostIP, Integer hostPort, String name, String protocol)`
`EphemeralContainerFluent.PortsNested<A>`	`addNewPortLike(ContainerPort item)`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`addNewResizePolicy()`
`A`	`addNewResizePolicy(String resourceName, String restartPolicy)`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`addNewResizePolicyLike(ContainerResizePolicy item)`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`addNewVolumeDevice()`
`A`	`addNewVolumeDevice(String devicePath, String name)`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`addNewVolumeDeviceLike(VolumeDevice item)`
`EphemeralContainerFluent.VolumeMountsNested<A>`	`addNewVolumeMount()`
`EphemeralContainerFluent.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(EphemeralContainer instance)`
`EphemeralContainerFluent.EnvNested<A>`	`editEnv(int index)`
`EphemeralContainerFluent.EnvFromNested<A>`	`editEnvFrom(int index)`
`EphemeralContainerFluent.EnvNested<A>`	`editFirstEnv()`
`EphemeralContainerFluent.EnvFromNested<A>`	`editFirstEnvFrom()`
`EphemeralContainerFluent.PortsNested<A>`	`editFirstPort()`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`editFirstResizePolicy()`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`editFirstVolumeDevice()`
`EphemeralContainerFluent.VolumeMountsNested<A>`	`editFirstVolumeMount()`
`EphemeralContainerFluent.EnvNested<A>`	`editLastEnv()`
`EphemeralContainerFluent.EnvFromNested<A>`	`editLastEnvFrom()`
`EphemeralContainerFluent.PortsNested<A>`	`editLastPort()`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`editLastResizePolicy()`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`editLastVolumeDevice()`
`EphemeralContainerFluent.VolumeMountsNested<A>`	`editLastVolumeMount()`
`EphemeralContainerFluent.LifecycleNested<A>`	`editLifecycle()`
`EphemeralContainerFluent.LivenessProbeNested<A>`	`editLivenessProbe()`
`EphemeralContainerFluent.EnvNested<A>`	`editMatchingEnv(Predicate<EnvVarBuilder> predicate)`
`EphemeralContainerFluent.EnvFromNested<A>`	`editMatchingEnvFrom(Predicate<EnvFromSourceBuilder> predicate)`
`EphemeralContainerFluent.PortsNested<A>`	`editMatchingPort(Predicate<ContainerPortBuilder> predicate)`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`editMatchingResizePolicy(Predicate<ContainerResizePolicyBuilder> predicate)`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`editMatchingVolumeDevice(Predicate<VolumeDeviceBuilder> predicate)`
`EphemeralContainerFluent.VolumeMountsNested<A>`	`editMatchingVolumeMount(Predicate<VolumeMountBuilder> predicate)`
`EphemeralContainerFluent.LifecycleNested<A>`	`editOrNewLifecycle()`
`EphemeralContainerFluent.LifecycleNested<A>`	`editOrNewLifecycleLike(Lifecycle item)`
`EphemeralContainerFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbe()`
`EphemeralContainerFluent.LivenessProbeNested<A>`	`editOrNewLivenessProbeLike(Probe item)`
`EphemeralContainerFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbe()`
`EphemeralContainerFluent.ReadinessProbeNested<A>`	`editOrNewReadinessProbeLike(Probe item)`
`EphemeralContainerFluent.ResourcesNested<A>`	`editOrNewResources()`
`EphemeralContainerFluent.ResourcesNested<A>`	`editOrNewResourcesLike(ResourceRequirements item)`
`EphemeralContainerFluent.SecurityContextNested<A>`	`editOrNewSecurityContext()`
`EphemeralContainerFluent.SecurityContextNested<A>`	`editOrNewSecurityContextLike(SecurityContext item)`
`EphemeralContainerFluent.StartupProbeNested<A>`	`editOrNewStartupProbe()`
`EphemeralContainerFluent.StartupProbeNested<A>`	`editOrNewStartupProbeLike(Probe item)`
`EphemeralContainerFluent.PortsNested<A>`	`editPort(int index)`
`EphemeralContainerFluent.ReadinessProbeNested<A>`	`editReadinessProbe()`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`editResizePolicy(int index)`
`EphemeralContainerFluent.ResourcesNested<A>`	`editResources()`
`EphemeralContainerFluent.SecurityContextNested<A>`	`editSecurityContext()`
`EphemeralContainerFluent.StartupProbeNested<A>`	`editStartupProbe()`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`editVolumeDevice(int index)`
`EphemeralContainerFluent.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`	`getTargetContainerName()`
`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`	`hasTargetContainerName()`
`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)`
`EphemeralContainerFluent.EnvFromNested<A>`	`setNewEnvFromLike(int index, EnvFromSource item)`
`EphemeralContainerFluent.EnvNested<A>`	`setNewEnvLike(int index, EnvVar item)`
`EphemeralContainerFluent.PortsNested<A>`	`setNewPortLike(int index, ContainerPort item)`
`EphemeralContainerFluent.ResizePolicyNested<A>`	`setNewResizePolicyLike(int index, ContainerResizePolicy item)`
`EphemeralContainerFluent.VolumeDevicesNested<A>`	`setNewVolumeDeviceLike(int index, VolumeDevice item)`
`EphemeralContainerFluent.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)`
`EphemeralContainerFluent.LifecycleNested<A>`	`withNewLifecycle()`
`EphemeralContainerFluent.LifecycleNested<A>`	`withNewLifecycleLike(Lifecycle item)`
`EphemeralContainerFluent.LivenessProbeNested<A>`	`withNewLivenessProbe()`
`EphemeralContainerFluent.LivenessProbeNested<A>`	`withNewLivenessProbeLike(Probe item)`
`EphemeralContainerFluent.ReadinessProbeNested<A>`	`withNewReadinessProbe()`
`EphemeralContainerFluent.ReadinessProbeNested<A>`	`withNewReadinessProbeLike(Probe item)`
`EphemeralContainerFluent.ResourcesNested<A>`	`withNewResources()`
`EphemeralContainerFluent.ResourcesNested<A>`	`withNewResourcesLike(ResourceRequirements item)`
`EphemeralContainerFluent.SecurityContextNested<A>`	`withNewSecurityContext()`
`EphemeralContainerFluent.SecurityContextNested<A>`	`withNewSecurityContextLike(SecurityContext item)`
`EphemeralContainerFluent.StartupProbeNested<A>`	`withNewStartupProbe()`
`EphemeralContainerFluent.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`	`withTargetContainerName(String targetContainerName)`
`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

EphemeralContainerFluent
```
public EphemeralContainerFluent()
```

EphemeralContainerFluent

public EphemeralContainerFluent(EphemeralContainer instance)

Method Detail

copyInstance

protected void copyInstance(EphemeralContainer 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 EphemeralContainerFluent.EnvNested<A> addNewEnv()

addNewEnvLike

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

setNewEnvLike

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

editEnv

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

editFirstEnv

public EphemeralContainerFluent.EnvNested<A> editFirstEnv()

editLastEnv

public EphemeralContainerFluent.EnvNested<A> editLastEnv()

editMatchingEnv

public EphemeralContainerFluent.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 EphemeralContainerFluent.EnvFromNested<A> addNewEnvFrom()

addNewEnvFromLike

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

setNewEnvFromLike

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

editEnvFrom

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

editFirstEnvFrom

public EphemeralContainerFluent.EnvFromNested<A> editFirstEnvFrom()

editLastEnvFrom

public EphemeralContainerFluent.EnvFromNested<A> editLastEnvFrom()

editMatchingEnvFrom

public EphemeralContainerFluent.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 EphemeralContainerFluent.LifecycleNested<A> withNewLifecycle()

withNewLifecycleLike

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

editLifecycle

public EphemeralContainerFluent.LifecycleNested<A> editLifecycle()

editOrNewLifecycle

public EphemeralContainerFluent.LifecycleNested<A> editOrNewLifecycle()

editOrNewLifecycleLike

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

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

withLivenessProbe

public A withLivenessProbe(Probe livenessProbe)

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

withNewLivenessProbe

public EphemeralContainerFluent.LivenessProbeNested<A> withNewLivenessProbe()

withNewLivenessProbeLike

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

editLivenessProbe

public EphemeralContainerFluent.LivenessProbeNested<A> editLivenessProbe()

editOrNewLivenessProbe

public EphemeralContainerFluent.LivenessProbeNested<A> editOrNewLivenessProbe()

editOrNewLivenessProbeLike

public EphemeralContainerFluent.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 EphemeralContainerFluent.PortsNested<A> addNewPort()

addNewPortLike

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

setNewPortLike

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

editPort

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

editFirstPort

public EphemeralContainerFluent.PortsNested<A> editFirstPort()

editLastPort

public EphemeralContainerFluent.PortsNested<A> editLastPort()

editMatchingPort

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

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

withReadinessProbe

public A withReadinessProbe(Probe readinessProbe)

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

withNewReadinessProbe

public EphemeralContainerFluent.ReadinessProbeNested<A> withNewReadinessProbe()

withNewReadinessProbeLike

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

editReadinessProbe

public EphemeralContainerFluent.ReadinessProbeNested<A> editReadinessProbe()

editOrNewReadinessProbe

public EphemeralContainerFluent.ReadinessProbeNested<A> editOrNewReadinessProbe()

editOrNewReadinessProbeLike

public EphemeralContainerFluent.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 EphemeralContainerFluent.ResizePolicyNested<A> addNewResizePolicy()

addNewResizePolicyLike

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

setNewResizePolicyLike

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

editResizePolicy

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

editFirstResizePolicy

public EphemeralContainerFluent.ResizePolicyNested<A> editFirstResizePolicy()

editLastResizePolicy

public EphemeralContainerFluent.ResizePolicyNested<A> editLastResizePolicy()

editMatchingResizePolicy

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

buildResources

public ResourceRequirements buildResources()

withResources

public A withResources(ResourceRequirements resources)

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

withNewResources

public EphemeralContainerFluent.ResourcesNested<A> withNewResources()

withNewResourcesLike

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

editResources

public EphemeralContainerFluent.ResourcesNested<A> editResources()

editOrNewResources

public EphemeralContainerFluent.ResourcesNested<A> editOrNewResources()

editOrNewResourcesLike

public EphemeralContainerFluent.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 EphemeralContainerFluent.SecurityContextNested<A> withNewSecurityContext()

withNewSecurityContextLike

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

editSecurityContext

public EphemeralContainerFluent.SecurityContextNested<A> editSecurityContext()

editOrNewSecurityContext

public EphemeralContainerFluent.SecurityContextNested<A> editOrNewSecurityContext()

editOrNewSecurityContextLike

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

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

withStartupProbe

public A withStartupProbe(Probe startupProbe)

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

withNewStartupProbe

public EphemeralContainerFluent.StartupProbeNested<A> withNewStartupProbe()

withNewStartupProbeLike

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

editStartupProbe

public EphemeralContainerFluent.StartupProbeNested<A> editStartupProbe()

editOrNewStartupProbe

public EphemeralContainerFluent.StartupProbeNested<A> editOrNewStartupProbe()

editOrNewStartupProbeLike

public EphemeralContainerFluent.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()
```

getTargetContainerName

public String getTargetContainerName()

withTargetContainerName

public A withTargetContainerName(String targetContainerName)

hasTargetContainerName

public boolean hasTargetContainerName()

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 EphemeralContainerFluent.VolumeDevicesNested<A> addNewVolumeDevice()

addNewVolumeDeviceLike

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

setNewVolumeDeviceLike

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

editVolumeDevice

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

editFirstVolumeDevice

public EphemeralContainerFluent.VolumeDevicesNested<A> editFirstVolumeDevice()

editLastVolumeDevice

public EphemeralContainerFluent.VolumeDevicesNested<A> editLastVolumeDevice()

editMatchingVolumeDevice

public EphemeralContainerFluent.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 EphemeralContainerFluent.VolumeMountsNested<A> addNewVolumeMount()

addNewVolumeMountLike

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

setNewVolumeMountLike

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

editVolumeMount

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

editFirstVolumeMount

public EphemeralContainerFluent.VolumeMountsNested<A> editFirstVolumeMount()

editLastVolumeMount

public EphemeralContainerFluent.VolumeMountsNested<A> editLastVolumeMount()

editMatchingVolumeMount

public EphemeralContainerFluent.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 EphemeralContainerFluent<A>>

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

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

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

toString in class Object

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

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

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

Constructor	Description
`EphemeralContainerFluent()`
`EphemeralContainerFluent(EphemeralContainer instance)`

Class EphemeralContainerFluent<A extends EphemeralContainerFluent<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

EphemeralContainerFluent

EphemeralContainerFluent

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