PhysicalMachineChaosSpecFluent (Fabric8 :: Chaos Mesh

java.lang.Object
- io.fabric8.kubernetes.api.builder.BaseFluent<A>
- - io.fabric8.chaosmesh.v1alpha1.PhysicalMachineChaosSpecFluent<A>

All Implemented Interfaces:

io.fabric8.kubernetes.api.builder.Fluent<A>, io.fabric8.kubernetes.api.builder.Visitable<A>

Direct Known Subclasses:

ChaosmeshSchemaFluent.GithubComChaosMeshChaosMeshApiV1alpha1PhysicalMachineChaosSpecNested, PhysicalMachineChaosFluent.SpecNested, PhysicalMachineChaosSpecBuilder
```
public class PhysicalMachineChaosSpecFluent<A extends PhysicalMachineChaosSpecFluent<A>>
extends io.fabric8.kubernetes.api.builder.BaseFluent<A>
```
Generated

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`PhysicalMachineChaosSpecFluent.ClockNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.DiskFillNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmExceptionNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmGcNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmLatencyNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmReturnNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.JvmStressNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkDelayNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkDnsNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkLossNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.ProcessNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.SelectorNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.StressCpuNested<N>`
`class`	`PhysicalMachineChaosSpecFluent.StressMemNested<N>`

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

Constructor Summary

Constructors
Constructor and Description

PhysicalMachineChaosSpecFluent()

PhysicalMachineChaosSpecFluent(PhysicalMachineChaosSpec instance)

Constructors
Constructor and Description
`PhysicalMachineChaosSpecFluent()`
`PhysicalMachineChaosSpecFluent(PhysicalMachineChaosSpec instance)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`A`	`addAllToAddress(Collection<String> items)`
`A`	`addToAddress(int index, String item)`
`A`	`addToAddress(String... items)`
`ClockSpec`	`buildClock()`
`DiskFillSpec`	`buildDiskFill()`
`DiskPayloadSpec`	`buildDiskReadPayload()`
`DiskPayloadSpec`	`buildDiskWritePayload()`
`JVMExceptionSpec`	`buildJvmException()`
`JVMGCSpec`	`buildJvmGc()`
`JVMLatencySpec`	`buildJvmLatency()`
`JVMReturnSpec`	`buildJvmReturn()`
`JVMRuleDataSpec`	`buildJvmRuleData()`
`JVMStressSpec`	`buildJvmStress()`
`NetworkBandwidthSpec`	`buildNetworkBandwidth()`
`NetworkCorruptSpec`	`buildNetworkCorrupt()`
`NetworkDelaySpec`	`buildNetworkDelay()`
`NetworkDNSSpec`	`buildNetworkDns()`
`NetworkDuplicateSpec`	`buildNetworkDuplicate()`
`NetworkLossSpec`	`buildNetworkLoss()`
`NetworkPartitionSpec`	`buildNetworkPartition()`
`ProcessSpec`	`buildProcess()`
`PhysicalMachineSelectorSpec`	`buildSelector()`
`StressCPUSpec`	`buildStressCpu()`
`StressMemorySpec`	`buildStressMem()`
`protected void`	`copyInstance(PhysicalMachineChaosSpec instance)`
`PhysicalMachineChaosSpecFluent.ClockNested<A>`	`editClock()`
`PhysicalMachineChaosSpecFluent.DiskFillNested<A>`	`editDiskFill()`
`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A>`	`editDiskReadPayload()`
`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A>`	`editDiskWritePayload()`
`PhysicalMachineChaosSpecFluent.JvmExceptionNested<A>`	`editJvmException()`
`PhysicalMachineChaosSpecFluent.JvmGcNested<A>`	`editJvmGc()`
`PhysicalMachineChaosSpecFluent.JvmLatencyNested<A>`	`editJvmLatency()`
`PhysicalMachineChaosSpecFluent.JvmReturnNested<A>`	`editJvmReturn()`
`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A>`	`editJvmRuleData()`
`PhysicalMachineChaosSpecFluent.JvmStressNested<A>`	`editJvmStress()`
`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A>`	`editNetworkBandwidth()`
`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A>`	`editNetworkCorrupt()`
`PhysicalMachineChaosSpecFluent.NetworkDelayNested<A>`	`editNetworkDelay()`
`PhysicalMachineChaosSpecFluent.NetworkDnsNested<A>`	`editNetworkDns()`
`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A>`	`editNetworkDuplicate()`
`PhysicalMachineChaosSpecFluent.NetworkLossNested<A>`	`editNetworkLoss()`
`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A>`	`editNetworkPartition()`
`PhysicalMachineChaosSpecFluent.ClockNested<A>`	`editOrNewClock()`
`PhysicalMachineChaosSpecFluent.ClockNested<A>`	`editOrNewClockLike(ClockSpec item)`
`PhysicalMachineChaosSpecFluent.DiskFillNested<A>`	`editOrNewDiskFill()`
`PhysicalMachineChaosSpecFluent.DiskFillNested<A>`	`editOrNewDiskFillLike(DiskFillSpec item)`
`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A>`	`editOrNewDiskReadPayload()`
`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A>`	`editOrNewDiskReadPayloadLike(DiskPayloadSpec item)`
`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A>`	`editOrNewDiskWritePayload()`
`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A>`	`editOrNewDiskWritePayloadLike(DiskPayloadSpec item)`
`PhysicalMachineChaosSpecFluent.JvmExceptionNested<A>`	`editOrNewJvmException()`
`PhysicalMachineChaosSpecFluent.JvmExceptionNested<A>`	`editOrNewJvmExceptionLike(JVMExceptionSpec item)`
`PhysicalMachineChaosSpecFluent.JvmGcNested<A>`	`editOrNewJvmGc()`
`PhysicalMachineChaosSpecFluent.JvmGcNested<A>`	`editOrNewJvmGcLike(JVMGCSpec item)`
`PhysicalMachineChaosSpecFluent.JvmLatencyNested<A>`	`editOrNewJvmLatency()`
`PhysicalMachineChaosSpecFluent.JvmLatencyNested<A>`	`editOrNewJvmLatencyLike(JVMLatencySpec item)`
`PhysicalMachineChaosSpecFluent.JvmReturnNested<A>`	`editOrNewJvmReturn()`
`PhysicalMachineChaosSpecFluent.JvmReturnNested<A>`	`editOrNewJvmReturnLike(JVMReturnSpec item)`
`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A>`	`editOrNewJvmRuleData()`
`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A>`	`editOrNewJvmRuleDataLike(JVMRuleDataSpec item)`
`PhysicalMachineChaosSpecFluent.JvmStressNested<A>`	`editOrNewJvmStress()`
`PhysicalMachineChaosSpecFluent.JvmStressNested<A>`	`editOrNewJvmStressLike(JVMStressSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A>`	`editOrNewNetworkBandwidth()`
`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A>`	`editOrNewNetworkBandwidthLike(NetworkBandwidthSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A>`	`editOrNewNetworkCorrupt()`
`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A>`	`editOrNewNetworkCorruptLike(NetworkCorruptSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDelayNested<A>`	`editOrNewNetworkDelay()`
`PhysicalMachineChaosSpecFluent.NetworkDelayNested<A>`	`editOrNewNetworkDelayLike(NetworkDelaySpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDnsNested<A>`	`editOrNewNetworkDns()`
`PhysicalMachineChaosSpecFluent.NetworkDnsNested<A>`	`editOrNewNetworkDnsLike(NetworkDNSSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A>`	`editOrNewNetworkDuplicate()`
`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A>`	`editOrNewNetworkDuplicateLike(NetworkDuplicateSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkLossNested<A>`	`editOrNewNetworkLoss()`
`PhysicalMachineChaosSpecFluent.NetworkLossNested<A>`	`editOrNewNetworkLossLike(NetworkLossSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A>`	`editOrNewNetworkPartition()`
`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A>`	`editOrNewNetworkPartitionLike(NetworkPartitionSpec item)`
`PhysicalMachineChaosSpecFluent.ProcessNested<A>`	`editOrNewProcess()`
`PhysicalMachineChaosSpecFluent.ProcessNested<A>`	`editOrNewProcessLike(ProcessSpec item)`
`PhysicalMachineChaosSpecFluent.SelectorNested<A>`	`editOrNewSelector()`
`PhysicalMachineChaosSpecFluent.SelectorNested<A>`	`editOrNewSelectorLike(PhysicalMachineSelectorSpec item)`
`PhysicalMachineChaosSpecFluent.StressCpuNested<A>`	`editOrNewStressCpu()`
`PhysicalMachineChaosSpecFluent.StressCpuNested<A>`	`editOrNewStressCpuLike(StressCPUSpec item)`
`PhysicalMachineChaosSpecFluent.StressMemNested<A>`	`editOrNewStressMem()`
`PhysicalMachineChaosSpecFluent.StressMemNested<A>`	`editOrNewStressMemLike(StressMemorySpec item)`
`PhysicalMachineChaosSpecFluent.ProcessNested<A>`	`editProcess()`
`PhysicalMachineChaosSpecFluent.SelectorNested<A>`	`editSelector()`
`PhysicalMachineChaosSpecFluent.StressCpuNested<A>`	`editStressCpu()`
`PhysicalMachineChaosSpecFluent.StressMemNested<A>`	`editStressMem()`
`boolean`	`equals(Object o)`
`String`	`getAction()`
`List<String>`	`getAddress()`
`String`	`getAddress(int index)`
`String`	`getDuration()`
`String`	`getFirstAddress()`
`String`	`getLastAddress()`
`String`	`getMatchingAddress(Predicate<String> predicate)`
`String`	`getMode()`
`String`	`getUid()`
`String`	`getValue()`
`boolean`	`hasAction()`
`boolean`	`hasAddress()`
`boolean`	`hasClock()`
`boolean`	`hasDiskFill()`
`boolean`	`hasDiskReadPayload()`
`boolean`	`hasDiskWritePayload()`
`boolean`	`hasDuration()`
`int`	`hashCode()`
`boolean`	`hasJvmException()`
`boolean`	`hasJvmGc()`
`boolean`	`hasJvmLatency()`
`boolean`	`hasJvmReturn()`
`boolean`	`hasJvmRuleData()`
`boolean`	`hasJvmStress()`
`boolean`	`hasMatchingAddress(Predicate<String> predicate)`
`boolean`	`hasMode()`
`boolean`	`hasNetworkBandwidth()`
`boolean`	`hasNetworkCorrupt()`
`boolean`	`hasNetworkDelay()`
`boolean`	`hasNetworkDns()`
`boolean`	`hasNetworkDuplicate()`
`boolean`	`hasNetworkLoss()`
`boolean`	`hasNetworkPartition()`
`boolean`	`hasProcess()`
`boolean`	`hasSelector()`
`boolean`	`hasStressCpu()`
`boolean`	`hasStressMem()`
`boolean`	`hasUid()`
`boolean`	`hasValue()`
`A`	`removeAllFromAddress(Collection<String> items)`
`A`	`removeFromAddress(String... items)`
`A`	`setToAddress(int index, String item)`
`String`	`toString()`
`A`	`withAction(String action)`
`A`	`withAddress(List<String> address)`
`A`	`withAddress(String... address)`
`A`	`withClock(ClockSpec clock)`
`A`	`withDiskFill(DiskFillSpec diskFill)`
`A`	`withDiskReadPayload(DiskPayloadSpec diskReadPayload)`
`A`	`withDiskWritePayload(DiskPayloadSpec diskWritePayload)`
`A`	`withDuration(String duration)`
`A`	`withJvmException(JVMExceptionSpec jvmException)`
`A`	`withJvmGc(JVMGCSpec jvmGc)`
`A`	`withJvmLatency(JVMLatencySpec jvmLatency)`
`A`	`withJvmReturn(JVMReturnSpec jvmReturn)`
`A`	`withJvmRuleData(JVMRuleDataSpec jvmRuleData)`
`A`	`withJvmStress(JVMStressSpec jvmStress)`
`A`	`withMode(String mode)`
`A`	`withNetworkBandwidth(NetworkBandwidthSpec networkBandwidth)`
`A`	`withNetworkCorrupt(NetworkCorruptSpec networkCorrupt)`
`A`	`withNetworkDelay(NetworkDelaySpec networkDelay)`
`A`	`withNetworkDns(NetworkDNSSpec networkDns)`
`A`	`withNetworkDuplicate(NetworkDuplicateSpec networkDuplicate)`
`A`	`withNetworkLoss(NetworkLossSpec networkLoss)`
`A`	`withNetworkPartition(NetworkPartitionSpec networkPartition)`
`PhysicalMachineChaosSpecFluent.ClockNested<A>`	`withNewClock()`
`A`	`withNewClock(String clockIdsSlice, Integer pid, String timeOffset)`
`PhysicalMachineChaosSpecFluent.ClockNested<A>`	`withNewClockLike(ClockSpec item)`
`PhysicalMachineChaosSpecFluent.DiskFillNested<A>`	`withNewDiskFill()`
`A`	`withNewDiskFill(Boolean fillByFallocate, String path, String size)`
`PhysicalMachineChaosSpecFluent.DiskFillNested<A>`	`withNewDiskFillLike(DiskFillSpec item)`
`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A>`	`withNewDiskReadPayload()`
`A`	`withNewDiskReadPayload(String path, Integer payloadProcessNum, String size)`
`PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A>`	`withNewDiskReadPayloadLike(DiskPayloadSpec item)`
`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A>`	`withNewDiskWritePayload()`
`A`	`withNewDiskWritePayload(String path, Integer payloadProcessNum, String size)`
`PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A>`	`withNewDiskWritePayloadLike(DiskPayloadSpec item)`
`PhysicalMachineChaosSpecFluent.JvmExceptionNested<A>`	`withNewJvmException()`
`A`	`withNewJvmException(String className, String exception, String method, Integer pid, Integer port)`
`PhysicalMachineChaosSpecFluent.JvmExceptionNested<A>`	`withNewJvmExceptionLike(JVMExceptionSpec item)`
`PhysicalMachineChaosSpecFluent.JvmGcNested<A>`	`withNewJvmGc()`
`A`	`withNewJvmGc(Integer pid, Integer port)`
`PhysicalMachineChaosSpecFluent.JvmGcNested<A>`	`withNewJvmGcLike(JVMGCSpec item)`
`PhysicalMachineChaosSpecFluent.JvmLatencyNested<A>`	`withNewJvmLatency()`
`A`	`withNewJvmLatency(String className, Integer latency, String method, Integer pid, Integer port)`
`PhysicalMachineChaosSpecFluent.JvmLatencyNested<A>`	`withNewJvmLatencyLike(JVMLatencySpec item)`
`PhysicalMachineChaosSpecFluent.JvmReturnNested<A>`	`withNewJvmReturn()`
`A`	`withNewJvmReturn(String className, String method, Integer pid, Integer port, String value)`
`PhysicalMachineChaosSpecFluent.JvmReturnNested<A>`	`withNewJvmReturnLike(JVMReturnSpec item)`
`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A>`	`withNewJvmRuleData()`
`A`	`withNewJvmRuleData(Integer pid, Integer port, String ruleData)`
`PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A>`	`withNewJvmRuleDataLike(JVMRuleDataSpec item)`
`PhysicalMachineChaosSpecFluent.JvmStressNested<A>`	`withNewJvmStress()`
`A`	`withNewJvmStress(Integer cpuCount, String memType, Integer pid, Integer port)`
`PhysicalMachineChaosSpecFluent.JvmStressNested<A>`	`withNewJvmStressLike(JVMStressSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A>`	`withNewNetworkBandwidth()`
`PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A>`	`withNewNetworkBandwidthLike(NetworkBandwidthSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A>`	`withNewNetworkCorrupt()`
`PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A>`	`withNewNetworkCorruptLike(NetworkCorruptSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDelayNested<A>`	`withNewNetworkDelay()`
`PhysicalMachineChaosSpecFluent.NetworkDelayNested<A>`	`withNewNetworkDelayLike(NetworkDelaySpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDnsNested<A>`	`withNewNetworkDns()`
`A`	`withNewNetworkDns(String dnsDomainName, String dnsIp, String dnsServer)`
`PhysicalMachineChaosSpecFluent.NetworkDnsNested<A>`	`withNewNetworkDnsLike(NetworkDNSSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A>`	`withNewNetworkDuplicate()`
`PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A>`	`withNewNetworkDuplicateLike(NetworkDuplicateSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkLossNested<A>`	`withNewNetworkLoss()`
`PhysicalMachineChaosSpecFluent.NetworkLossNested<A>`	`withNewNetworkLossLike(NetworkLossSpec item)`
`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A>`	`withNewNetworkPartition()`
`PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A>`	`withNewNetworkPartitionLike(NetworkPartitionSpec item)`
`PhysicalMachineChaosSpecFluent.ProcessNested<A>`	`withNewProcess()`
`A`	`withNewProcess(String process, Integer signal)`
`PhysicalMachineChaosSpecFluent.ProcessNested<A>`	`withNewProcessLike(ProcessSpec item)`
`PhysicalMachineChaosSpecFluent.SelectorNested<A>`	`withNewSelector()`
`PhysicalMachineChaosSpecFluent.SelectorNested<A>`	`withNewSelectorLike(PhysicalMachineSelectorSpec item)`
`PhysicalMachineChaosSpecFluent.StressCpuNested<A>`	`withNewStressCpu()`
`A`	`withNewStressCpu(Integer load, String options, Integer workers)`
`PhysicalMachineChaosSpecFluent.StressCpuNested<A>`	`withNewStressCpuLike(StressCPUSpec item)`
`PhysicalMachineChaosSpecFluent.StressMemNested<A>`	`withNewStressMem()`
`A`	`withNewStressMem(String options, String size)`
`PhysicalMachineChaosSpecFluent.StressMemNested<A>`	`withNewStressMemLike(StressMemorySpec item)`
`A`	`withProcess(ProcessSpec process)`
`A`	`withSelector(PhysicalMachineSelectorSpec selector)`
`A`	`withStressCpu(StressCPUSpec stressCpu)`
`A`	`withStressMem(StressMemorySpec stressMem)`
`A`	`withUid(String uid)`
`A`	`withValue(String value)`

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

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

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable
getTarget

Constructor Detail

PhysicalMachineChaosSpecFluent

public PhysicalMachineChaosSpecFluent()

PhysicalMachineChaosSpecFluent

public PhysicalMachineChaosSpecFluent(PhysicalMachineChaosSpec instance)

Method Detail

copyInstance

protected void copyInstance(PhysicalMachineChaosSpec instance)

getAction
```
public String getAction()
```

withAction
```
public A withAction(String action)
```

hasAction
```
public boolean hasAction()
```

addToAddress

public A addToAddress(int index,
                      String item)

setToAddress

public A setToAddress(int index,
                      String item)

addToAddress

public A addToAddress(String... items)

addAllToAddress

public A addAllToAddress(Collection<String> items)

removeFromAddress

public A removeFromAddress(String... items)

removeAllFromAddress

public A removeAllFromAddress(Collection<String> items)

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

getAddress
```
public String getAddress(int index)
```

getFirstAddress
```
public String getFirstAddress()
```

getLastAddress
```
public String getLastAddress()
```

getMatchingAddress

public String getMatchingAddress(Predicate<String> predicate)

hasMatchingAddress

public boolean hasMatchingAddress(Predicate<String> predicate)

withAddress

public A withAddress(List<String> address)

withAddress

public A withAddress(String... address)

hasAddress
```
public boolean hasAddress()
```

buildClock
```
public ClockSpec buildClock()
```

withClock
```
public A withClock(ClockSpec clock)
```

hasClock
```
public boolean hasClock()
```

withNewClock

public A withNewClock(String clockIdsSlice,
                      Integer pid,
                      String timeOffset)

withNewClock

public PhysicalMachineChaosSpecFluent.ClockNested<A> withNewClock()

withNewClockLike

public PhysicalMachineChaosSpecFluent.ClockNested<A> withNewClockLike(ClockSpec item)

editClock

public PhysicalMachineChaosSpecFluent.ClockNested<A> editClock()

editOrNewClock

public PhysicalMachineChaosSpecFluent.ClockNested<A> editOrNewClock()

editOrNewClockLike

public PhysicalMachineChaosSpecFluent.ClockNested<A> editOrNewClockLike(ClockSpec item)

buildDiskFill
```
public DiskFillSpec buildDiskFill()
```

withDiskFill

public A withDiskFill(DiskFillSpec diskFill)

hasDiskFill
```
public boolean hasDiskFill()
```

withNewDiskFill

public A withNewDiskFill(Boolean fillByFallocate,
                         String path,
                         String size)

withNewDiskFill

public PhysicalMachineChaosSpecFluent.DiskFillNested<A> withNewDiskFill()

withNewDiskFillLike

public PhysicalMachineChaosSpecFluent.DiskFillNested<A> withNewDiskFillLike(DiskFillSpec item)

editDiskFill

public PhysicalMachineChaosSpecFluent.DiskFillNested<A> editDiskFill()

editOrNewDiskFill

public PhysicalMachineChaosSpecFluent.DiskFillNested<A> editOrNewDiskFill()

editOrNewDiskFillLike

public PhysicalMachineChaosSpecFluent.DiskFillNested<A> editOrNewDiskFillLike(DiskFillSpec item)

buildDiskReadPayload

public DiskPayloadSpec buildDiskReadPayload()

withDiskReadPayload

public A withDiskReadPayload(DiskPayloadSpec diskReadPayload)

hasDiskReadPayload
```
public boolean hasDiskReadPayload()
```

withNewDiskReadPayload

public A withNewDiskReadPayload(String path,
                                Integer payloadProcessNum,
                                String size)

withNewDiskReadPayload

public PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A> withNewDiskReadPayload()

withNewDiskReadPayloadLike

public PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A> withNewDiskReadPayloadLike(DiskPayloadSpec item)

editDiskReadPayload

public PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A> editDiskReadPayload()

editOrNewDiskReadPayload

public PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A> editOrNewDiskReadPayload()

editOrNewDiskReadPayloadLike

public PhysicalMachineChaosSpecFluent.DiskReadPayloadNested<A> editOrNewDiskReadPayloadLike(DiskPayloadSpec item)

buildDiskWritePayload

public DiskPayloadSpec buildDiskWritePayload()

withDiskWritePayload

public A withDiskWritePayload(DiskPayloadSpec diskWritePayload)

hasDiskWritePayload
```
public boolean hasDiskWritePayload()
```

withNewDiskWritePayload

public A withNewDiskWritePayload(String path,
                                 Integer payloadProcessNum,
                                 String size)

withNewDiskWritePayload

public PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A> withNewDiskWritePayload()

withNewDiskWritePayloadLike

public PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A> withNewDiskWritePayloadLike(DiskPayloadSpec item)

editDiskWritePayload

public PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A> editDiskWritePayload()

editOrNewDiskWritePayload

public PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A> editOrNewDiskWritePayload()

editOrNewDiskWritePayloadLike

public PhysicalMachineChaosSpecFluent.DiskWritePayloadNested<A> editOrNewDiskWritePayloadLike(DiskPayloadSpec item)

getDuration
```
public String getDuration()
```

withDuration

public A withDuration(String duration)

hasDuration
```
public boolean hasDuration()
```

buildJvmException

public JVMExceptionSpec buildJvmException()

withJvmException

public A withJvmException(JVMExceptionSpec jvmException)

hasJvmException
```
public boolean hasJvmException()
```

withNewJvmException

public A withNewJvmException(String className,
                             String exception,
                             String method,
                             Integer pid,
                             Integer port)

withNewJvmException

public PhysicalMachineChaosSpecFluent.JvmExceptionNested<A> withNewJvmException()

withNewJvmExceptionLike

public PhysicalMachineChaosSpecFluent.JvmExceptionNested<A> withNewJvmExceptionLike(JVMExceptionSpec item)

editJvmException

public PhysicalMachineChaosSpecFluent.JvmExceptionNested<A> editJvmException()

editOrNewJvmException

public PhysicalMachineChaosSpecFluent.JvmExceptionNested<A> editOrNewJvmException()

editOrNewJvmExceptionLike

public PhysicalMachineChaosSpecFluent.JvmExceptionNested<A> editOrNewJvmExceptionLike(JVMExceptionSpec item)

buildJvmGc
```
public JVMGCSpec buildJvmGc()
```

withJvmGc
```
public A withJvmGc(JVMGCSpec jvmGc)
```

hasJvmGc
```
public boolean hasJvmGc()
```

withNewJvmGc

public A withNewJvmGc(Integer pid,
                      Integer port)

withNewJvmGc

public PhysicalMachineChaosSpecFluent.JvmGcNested<A> withNewJvmGc()

withNewJvmGcLike

public PhysicalMachineChaosSpecFluent.JvmGcNested<A> withNewJvmGcLike(JVMGCSpec item)

editJvmGc

public PhysicalMachineChaosSpecFluent.JvmGcNested<A> editJvmGc()

editOrNewJvmGc

public PhysicalMachineChaosSpecFluent.JvmGcNested<A> editOrNewJvmGc()

editOrNewJvmGcLike

public PhysicalMachineChaosSpecFluent.JvmGcNested<A> editOrNewJvmGcLike(JVMGCSpec item)

buildJvmLatency

public JVMLatencySpec buildJvmLatency()

withJvmLatency

public A withJvmLatency(JVMLatencySpec jvmLatency)

hasJvmLatency
```
public boolean hasJvmLatency()
```

withNewJvmLatency

public A withNewJvmLatency(String className,
                           Integer latency,
                           String method,
                           Integer pid,
                           Integer port)

withNewJvmLatency

public PhysicalMachineChaosSpecFluent.JvmLatencyNested<A> withNewJvmLatency()

withNewJvmLatencyLike

public PhysicalMachineChaosSpecFluent.JvmLatencyNested<A> withNewJvmLatencyLike(JVMLatencySpec item)

editJvmLatency

public PhysicalMachineChaosSpecFluent.JvmLatencyNested<A> editJvmLatency()

editOrNewJvmLatency

public PhysicalMachineChaosSpecFluent.JvmLatencyNested<A> editOrNewJvmLatency()

editOrNewJvmLatencyLike

public PhysicalMachineChaosSpecFluent.JvmLatencyNested<A> editOrNewJvmLatencyLike(JVMLatencySpec item)

buildJvmReturn
```
public JVMReturnSpec buildJvmReturn()
```

withJvmReturn

public A withJvmReturn(JVMReturnSpec jvmReturn)

hasJvmReturn
```
public boolean hasJvmReturn()
```

withNewJvmReturn

public A withNewJvmReturn(String className,
                          String method,
                          Integer pid,
                          Integer port,
                          String value)

withNewJvmReturn

public PhysicalMachineChaosSpecFluent.JvmReturnNested<A> withNewJvmReturn()

withNewJvmReturnLike

public PhysicalMachineChaosSpecFluent.JvmReturnNested<A> withNewJvmReturnLike(JVMReturnSpec item)

editJvmReturn

public PhysicalMachineChaosSpecFluent.JvmReturnNested<A> editJvmReturn()

editOrNewJvmReturn

public PhysicalMachineChaosSpecFluent.JvmReturnNested<A> editOrNewJvmReturn()

editOrNewJvmReturnLike

public PhysicalMachineChaosSpecFluent.JvmReturnNested<A> editOrNewJvmReturnLike(JVMReturnSpec item)

buildJvmRuleData

public JVMRuleDataSpec buildJvmRuleData()

withJvmRuleData

public A withJvmRuleData(JVMRuleDataSpec jvmRuleData)

hasJvmRuleData
```
public boolean hasJvmRuleData()
```

withNewJvmRuleData

public A withNewJvmRuleData(Integer pid,
                            Integer port,
                            String ruleData)

withNewJvmRuleData

public PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A> withNewJvmRuleData()

withNewJvmRuleDataLike

public PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A> withNewJvmRuleDataLike(JVMRuleDataSpec item)

editJvmRuleData

public PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A> editJvmRuleData()

editOrNewJvmRuleData

public PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A> editOrNewJvmRuleData()

editOrNewJvmRuleDataLike

public PhysicalMachineChaosSpecFluent.JvmRuleDataNested<A> editOrNewJvmRuleDataLike(JVMRuleDataSpec item)

buildJvmStress
```
public JVMStressSpec buildJvmStress()
```

withJvmStress

public A withJvmStress(JVMStressSpec jvmStress)

hasJvmStress
```
public boolean hasJvmStress()
```

withNewJvmStress

public A withNewJvmStress(Integer cpuCount,
                          String memType,
                          Integer pid,
                          Integer port)

withNewJvmStress

public PhysicalMachineChaosSpecFluent.JvmStressNested<A> withNewJvmStress()

withNewJvmStressLike

public PhysicalMachineChaosSpecFluent.JvmStressNested<A> withNewJvmStressLike(JVMStressSpec item)

editJvmStress

public PhysicalMachineChaosSpecFluent.JvmStressNested<A> editJvmStress()

editOrNewJvmStress

public PhysicalMachineChaosSpecFluent.JvmStressNested<A> editOrNewJvmStress()

editOrNewJvmStressLike

public PhysicalMachineChaosSpecFluent.JvmStressNested<A> editOrNewJvmStressLike(JVMStressSpec item)

getMode
```
public String getMode()
```

withMode
```
public A withMode(String mode)
```

hasMode
```
public boolean hasMode()
```

buildNetworkBandwidth

public NetworkBandwidthSpec buildNetworkBandwidth()

withNetworkBandwidth

public A withNetworkBandwidth(NetworkBandwidthSpec networkBandwidth)

hasNetworkBandwidth
```
public boolean hasNetworkBandwidth()
```

withNewNetworkBandwidth

public PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A> withNewNetworkBandwidth()

withNewNetworkBandwidthLike

public PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A> withNewNetworkBandwidthLike(NetworkBandwidthSpec item)

editNetworkBandwidth

public PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A> editNetworkBandwidth()

editOrNewNetworkBandwidth

public PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A> editOrNewNetworkBandwidth()

editOrNewNetworkBandwidthLike

public PhysicalMachineChaosSpecFluent.NetworkBandwidthNested<A> editOrNewNetworkBandwidthLike(NetworkBandwidthSpec item)

buildNetworkCorrupt

public NetworkCorruptSpec buildNetworkCorrupt()

withNetworkCorrupt

public A withNetworkCorrupt(NetworkCorruptSpec networkCorrupt)

hasNetworkCorrupt
```
public boolean hasNetworkCorrupt()
```

withNewNetworkCorrupt

public PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A> withNewNetworkCorrupt()

withNewNetworkCorruptLike

public PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A> withNewNetworkCorruptLike(NetworkCorruptSpec item)

editNetworkCorrupt

public PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A> editNetworkCorrupt()

editOrNewNetworkCorrupt

public PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A> editOrNewNetworkCorrupt()

editOrNewNetworkCorruptLike

public PhysicalMachineChaosSpecFluent.NetworkCorruptNested<A> editOrNewNetworkCorruptLike(NetworkCorruptSpec item)

buildNetworkDelay

public NetworkDelaySpec buildNetworkDelay()

withNetworkDelay

public A withNetworkDelay(NetworkDelaySpec networkDelay)

hasNetworkDelay
```
public boolean hasNetworkDelay()
```

withNewNetworkDelay

public PhysicalMachineChaosSpecFluent.NetworkDelayNested<A> withNewNetworkDelay()

withNewNetworkDelayLike

public PhysicalMachineChaosSpecFluent.NetworkDelayNested<A> withNewNetworkDelayLike(NetworkDelaySpec item)

editNetworkDelay

public PhysicalMachineChaosSpecFluent.NetworkDelayNested<A> editNetworkDelay()

editOrNewNetworkDelay

public PhysicalMachineChaosSpecFluent.NetworkDelayNested<A> editOrNewNetworkDelay()

editOrNewNetworkDelayLike

public PhysicalMachineChaosSpecFluent.NetworkDelayNested<A> editOrNewNetworkDelayLike(NetworkDelaySpec item)

buildNetworkDns

public NetworkDNSSpec buildNetworkDns()

withNetworkDns

public A withNetworkDns(NetworkDNSSpec networkDns)

hasNetworkDns
```
public boolean hasNetworkDns()
```

withNewNetworkDns

public A withNewNetworkDns(String dnsDomainName,
                           String dnsIp,
                           String dnsServer)

withNewNetworkDns

public PhysicalMachineChaosSpecFluent.NetworkDnsNested<A> withNewNetworkDns()

withNewNetworkDnsLike

public PhysicalMachineChaosSpecFluent.NetworkDnsNested<A> withNewNetworkDnsLike(NetworkDNSSpec item)

editNetworkDns

public PhysicalMachineChaosSpecFluent.NetworkDnsNested<A> editNetworkDns()

editOrNewNetworkDns

public PhysicalMachineChaosSpecFluent.NetworkDnsNested<A> editOrNewNetworkDns()

editOrNewNetworkDnsLike

public PhysicalMachineChaosSpecFluent.NetworkDnsNested<A> editOrNewNetworkDnsLike(NetworkDNSSpec item)

buildNetworkDuplicate

public NetworkDuplicateSpec buildNetworkDuplicate()

withNetworkDuplicate

public A withNetworkDuplicate(NetworkDuplicateSpec networkDuplicate)

hasNetworkDuplicate
```
public boolean hasNetworkDuplicate()
```

withNewNetworkDuplicate

public PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A> withNewNetworkDuplicate()

withNewNetworkDuplicateLike

public PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A> withNewNetworkDuplicateLike(NetworkDuplicateSpec item)

editNetworkDuplicate

public PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A> editNetworkDuplicate()

editOrNewNetworkDuplicate

public PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A> editOrNewNetworkDuplicate()

editOrNewNetworkDuplicateLike

public PhysicalMachineChaosSpecFluent.NetworkDuplicateNested<A> editOrNewNetworkDuplicateLike(NetworkDuplicateSpec item)

buildNetworkLoss

public NetworkLossSpec buildNetworkLoss()

withNetworkLoss

public A withNetworkLoss(NetworkLossSpec networkLoss)

hasNetworkLoss
```
public boolean hasNetworkLoss()
```

withNewNetworkLoss

public PhysicalMachineChaosSpecFluent.NetworkLossNested<A> withNewNetworkLoss()

withNewNetworkLossLike

public PhysicalMachineChaosSpecFluent.NetworkLossNested<A> withNewNetworkLossLike(NetworkLossSpec item)

editNetworkLoss

public PhysicalMachineChaosSpecFluent.NetworkLossNested<A> editNetworkLoss()

editOrNewNetworkLoss

public PhysicalMachineChaosSpecFluent.NetworkLossNested<A> editOrNewNetworkLoss()

editOrNewNetworkLossLike

public PhysicalMachineChaosSpecFluent.NetworkLossNested<A> editOrNewNetworkLossLike(NetworkLossSpec item)

buildNetworkPartition

public NetworkPartitionSpec buildNetworkPartition()

withNetworkPartition

public A withNetworkPartition(NetworkPartitionSpec networkPartition)

hasNetworkPartition
```
public boolean hasNetworkPartition()
```

withNewNetworkPartition

public PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A> withNewNetworkPartition()

withNewNetworkPartitionLike

public PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A> withNewNetworkPartitionLike(NetworkPartitionSpec item)

editNetworkPartition

public PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A> editNetworkPartition()

editOrNewNetworkPartition

public PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A> editOrNewNetworkPartition()

editOrNewNetworkPartitionLike

public PhysicalMachineChaosSpecFluent.NetworkPartitionNested<A> editOrNewNetworkPartitionLike(NetworkPartitionSpec item)

buildProcess
```
public ProcessSpec buildProcess()
```

withProcess

public A withProcess(ProcessSpec process)

hasProcess
```
public boolean hasProcess()
```

withNewProcess

public A withNewProcess(String process,
                        Integer signal)

withNewProcess

public PhysicalMachineChaosSpecFluent.ProcessNested<A> withNewProcess()

withNewProcessLike

public PhysicalMachineChaosSpecFluent.ProcessNested<A> withNewProcessLike(ProcessSpec item)

editProcess

public PhysicalMachineChaosSpecFluent.ProcessNested<A> editProcess()

editOrNewProcess

public PhysicalMachineChaosSpecFluent.ProcessNested<A> editOrNewProcess()

editOrNewProcessLike

public PhysicalMachineChaosSpecFluent.ProcessNested<A> editOrNewProcessLike(ProcessSpec item)

buildSelector

public PhysicalMachineSelectorSpec buildSelector()

withSelector

public A withSelector(PhysicalMachineSelectorSpec selector)

hasSelector
```
public boolean hasSelector()
```

withNewSelector

public PhysicalMachineChaosSpecFluent.SelectorNested<A> withNewSelector()

withNewSelectorLike

public PhysicalMachineChaosSpecFluent.SelectorNested<A> withNewSelectorLike(PhysicalMachineSelectorSpec item)

editSelector

public PhysicalMachineChaosSpecFluent.SelectorNested<A> editSelector()

editOrNewSelector

public PhysicalMachineChaosSpecFluent.SelectorNested<A> editOrNewSelector()

editOrNewSelectorLike

public PhysicalMachineChaosSpecFluent.SelectorNested<A> editOrNewSelectorLike(PhysicalMachineSelectorSpec item)

buildStressCpu
```
public StressCPUSpec buildStressCpu()
```

withStressCpu

public A withStressCpu(StressCPUSpec stressCpu)

hasStressCpu
```
public boolean hasStressCpu()
```

withNewStressCpu

public A withNewStressCpu(Integer load,
                          String options,
                          Integer workers)

withNewStressCpu

public PhysicalMachineChaosSpecFluent.StressCpuNested<A> withNewStressCpu()

withNewStressCpuLike

public PhysicalMachineChaosSpecFluent.StressCpuNested<A> withNewStressCpuLike(StressCPUSpec item)

editStressCpu

public PhysicalMachineChaosSpecFluent.StressCpuNested<A> editStressCpu()

editOrNewStressCpu

public PhysicalMachineChaosSpecFluent.StressCpuNested<A> editOrNewStressCpu()

editOrNewStressCpuLike

public PhysicalMachineChaosSpecFluent.StressCpuNested<A> editOrNewStressCpuLike(StressCPUSpec item)

buildStressMem

public StressMemorySpec buildStressMem()

withStressMem

public A withStressMem(StressMemorySpec stressMem)

hasStressMem
```
public boolean hasStressMem()
```

withNewStressMem

public A withNewStressMem(String options,
                          String size)

withNewStressMem

public PhysicalMachineChaosSpecFluent.StressMemNested<A> withNewStressMem()

withNewStressMemLike

public PhysicalMachineChaosSpecFluent.StressMemNested<A> withNewStressMemLike(StressMemorySpec item)

editStressMem

public PhysicalMachineChaosSpecFluent.StressMemNested<A> editStressMem()

editOrNewStressMem

public PhysicalMachineChaosSpecFluent.StressMemNested<A> editOrNewStressMem()

editOrNewStressMemLike

public PhysicalMachineChaosSpecFluent.StressMemNested<A> editOrNewStressMemLike(StressMemorySpec item)

getUid
```
public String getUid()
```

withUid
```
public A withUid(String uid)
```

hasUid
```
public boolean hasUid()
```

getValue
```
public String getValue()
```

withValue
```
public A withValue(String value)
```

hasValue
```
public boolean hasValue()
```

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

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

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

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

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

toString in class Object

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

Methods inherited from interface io.fabric8.kubernetes.api.builder.Visitable

Constructor Detail

PhysicalMachineChaosSpecFluent

PhysicalMachineChaosSpecFluent

Method Detail

copyInstance

getAction

withAction

hasAction

addToAddress

setToAddress

addToAddress

addAllToAddress

removeFromAddress

removeAllFromAddress

getAddress

getAddress

getFirstAddress

getLastAddress

getMatchingAddress

hasMatchingAddress

withAddress

withAddress

hasAddress

buildClock

withClock

hasClock

withNewClock

withNewClock

withNewClockLike

editClock

editOrNewClock

editOrNewClockLike

buildDiskFill

withDiskFill

hasDiskFill

withNewDiskFill

withNewDiskFill

withNewDiskFillLike

editDiskFill

editOrNewDiskFill

editOrNewDiskFillLike

buildDiskReadPayload

withDiskReadPayload

hasDiskReadPayload

withNewDiskReadPayload

withNewDiskReadPayload

withNewDiskReadPayloadLike

editDiskReadPayload

editOrNewDiskReadPayload

editOrNewDiskReadPayloadLike

buildDiskWritePayload

withDiskWritePayload

hasDiskWritePayload

withNewDiskWritePayload

withNewDiskWritePayload

withNewDiskWritePayloadLike

editDiskWritePayload

editOrNewDiskWritePayload

editOrNewDiskWritePayloadLike

getDuration

withDuration

hasDuration

buildJvmException

withJvmException

hasJvmException

withNewJvmException

withNewJvmException

withNewJvmExceptionLike

editJvmException

editOrNewJvmException

editOrNewJvmExceptionLike