def stress_cpu(filter: str = None,
duration: int = 120,
timeout: int = 60,
instance_criteria: Iterable[Mapping[str, any]] = None,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Stresses the CPU of a random VMSS instances in your selected VMSS.
Similar to the stress_cpu action of the machine.actions module.
Parameters
----------
filter : str, optional
Filter the VMSS. If the filter is omitted all VMSS in
the subscription will be selected as potential chaos candidates.
duration : int, optional
Duration of the stress test (in seconds) that generates high CPU usage.
Defaults to 120 seconds.
timeout : int
Additional wait time (in seconds) for stress operation to be completed.
Getting and sending data from/to Azure may take some time so it's not
recommended to set this value to less than 30s. Defaults to 60 seconds.
"""
logger.debug(
"Starting stress_vmss_instance_cpu:"
" configuration='{}', filter='{}',"
" duration='{}', timeout='{}'".format(
configuration, filter, duration, timeout))
vmss_records = Records()
vmss = fetch_vmss(filter, configuration, secrets)
for scale_set in vmss:
instances_records = Records()
instances = fetch_instances(scale_set, instance_criteria,
configuration, secrets)
for instance in instances:
command_id, script_content = command.prepare(instance,
'cpu_stress_test')
parameters = {
'command_id': command_id,
'script': [script_content],
'parameters': [
{'name': "duration", 'value': duration}
]
}
logger.debug(
"Stressing CPU of VMSS instance: '{}'".format(
instance['instance_id']))
_timeout = duration + timeout
command.run(
scale_set['resourceGroup'], instance, _timeout, parameters,
secrets, configuration)
instances_records.add(cleanse.vmss_instance(instance))
scale_set['virtualMachines'] = instances_records.output()
vmss_records.add(cleanse.vmss(scale_set))
return vmss_records.output_as_dict('resources')
def network_latency(filter: str = None,
duration: int = 60,
delay: int = 200,
jitter: int = 50,
timeout: int = 60,
instance_criteria: Iterable[Mapping[str, any]] = None,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Increases the response time of the virtual machine. Similar to
the network_latency action of the machine.actions module.
"""
logger.debug(
"Starting network_latency: configuration='{}', filter='{}',"
" duration='{}', delay='{}', jitter='{}', timeout='{}'".format(
configuration, filter, duration, delay, jitter, timeout))
vmss = fetch_vmss(filter, configuration, secrets)
vmss_records = Records()
for scale_set in vmss:
instances_records = Records()
instances = fetch_instances(scale_set, instance_criteria,
configuration, secrets)
for instance in instances:
command_id, script_content = command.prepare(
instance, 'network_latency')
parameters = {
'command_id':
command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}, {
'name': "delay",
'value': delay
}, {
'name': "jitter",
'value': jitter
}]
}
logger.debug(
"Increasing the latency of VMSS instance: '{}'".format(
instance['name']))
_timeout = duration + timeout
command.run(scale_set['resourceGroup'], instance, _timeout,
parameters, secrets, configuration)
instances_records.add(cleanse.vmss_instance(instance))
scale_set['virtualMachines'] = instances_records.output()
vmss_records.add(cleanse.vmss(scale_set))
return vmss_records.output_as_dict('resources')
def fill_disk(filter: str = None,
duration: int = 120,
timeout: int = 60,
size: int = 1000,
path: str = None,
instance_criteria: Iterable[Mapping[str, any]] = None,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Fill the VMSS machine disk with random data. Similar to
the fill_disk action of the machine.actions module.
"""
logger.debug("Starting fill_disk: configuration='{}', filter='{}',"
" duration='{}', size='{}', path='{}', timeout='{}'".format(
configuration, filter, duration, size, path, timeout))
vmss = fetch_vmss(filter, configuration, secrets)
vmss_records = Records()
for scale_set in vmss:
instances_records = Records()
instances = fetch_instances(scale_set, instance_criteria,
configuration, secrets)
for instance in instances:
command_id, script_content = command.prepare(instance, 'fill_disk')
fill_path = command.prepare_path(instance, path)
parameters = {
'command_id':
command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}, {
'name': "size",
'value': size
}, {
'name': "path",
'value': fill_path
}]
}
logger.debug("Filling disk of VMSS instance: '{}'".format(
instance['name']))
_timeout = duration + timeout
command.run(scale_set['resourceGroup'], instance, _timeout,
parameters, secrets, configuration)
instances_records.add(cleanse.vmss_instance(instance))
scale_set['virtualMachines'] = instances_records.output()
vmss_records.add(cleanse.vmss(scale_set))
return vmss_records.output_as_dict('resources')
def burn_io(filter: str = None,
duration: int = 60,
timeout: int = 60,
instance_criteria: Iterable[Mapping[str, any]] = None,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Increases the Disk I/O operations per second of the VMSS machine.
Similar to the burn_io action of the machine.actions module.
"""
logger.debug(
"Starting burn_io: configuration='{}', filter='{}', duration='{}',"
" timeout='{}'".format(configuration, filter, duration, timeout))
vmss = fetch_vmss(filter, configuration, secrets)
vmss_records = Records()
for scale_set in vmss:
instances_records = Records()
instances = fetch_instances(scale_set, instance_criteria,
configuration, secrets)
for instance in instances:
command_id, script_content = command.prepare(instance, 'burn_io')
parameters = {
'command_id': command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}]
}
logger.debug("Burning IO of VMSS instance: '{}'".format(
instance['name']))
_timeout = duration + timeout
command.run(scale_set['resourceGroup'], instance, _timeout,
parameters, secrets, configuration)
instances_records.add(cleanse.vmss_instance(instance))
scale_set['virtualMachines'] = instances_records.output()
vmss_records.add(cleanse.vmss(scale_set))
return vmss_records.output_as_dict('resources')
def burn_io(filter: str = None,
duration: int = 60,
timeout: int = 60,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Increases the Disk I/O operations per second of the virtual machine.
Parameters
----------
filter : str, optional
Filter the virtual machines. If the filter is omitted all machines in
the subscription will be selected as potential chaos candidates.
duration : int, optional
How long the burn lasts. Defaults to 60 seconds.
timeout : int
Additional wait time (in seconds) for filling operation to be completed
Getting and sending data from/to Azure may take some time so it's not
recommended to set this value to less than 30s. Defaults to 60 seconds.
Examples
--------
Some calling examples. Deep dive into the filter syntax:
https://docs.microsoft.com/en-us/azure/kusto/query/
>>> burn_io("where resourceGroup=='rg'", configuration=c, secrets=s)
Increase the I/O operations per second of all machines from the group 'rg'
>>> burn_io("where resourceGroup=='rg' and name='name'",
configuration=c, secrets=s)
Increase the I/O operations per second of the machine from the group 'rg'
having the name 'name'
>>> burn_io("where resourceGroup=='rg' | sample 2",
configuration=c, secrets=s)
Increase the I/O operations per second of two machines at random from
the group 'rg'
"""
msg = "Starting burn_io: configuration='{}', filter='{}', duration='{}'," \
" timeout='{}'".format(configuration, filter, duration, timeout)
logger.debug(msg)
machines = __fetch_machines(filter, configuration, secrets)
machine_records = Records()
for machine in machines:
command_id, script_content = command.prepare(machine, 'burn_io')
parameters = {
'command_id': command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}]
}
logger.debug("Burning IO of machine: '{}'".format(machine['name']))
_timeout = duration + timeout
command.run(machine['resourceGroup'], machine, _timeout, parameters,
secrets, configuration)
machine_records.add(cleanse.machine(machine))
return machine_records.output_as_dict('resources')
def network_latency(filter: str = None,
duration: int = 60,
delay: int = 200,
jitter: int = 50,
timeout: int = 60,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Increases the response time of the virtual machine.
Parameters
----------
filter : str, optional
Filter the virtual machines. If the filter is omitted all machines in
the subscription will be selected as potential chaos candidates.
duration : int, optional
How long the latency lasts. Defaults to 60 seconds.
timeout : int
Additional wait time (in seconds) for filling operation to be completed
Getting and sending data from/to Azure may take some time so it's not
recommended to set this value to less than 30s. Defaults to 60 seconds.
delay : int
Added delay in ms. Defaults to 200.
jitter : int
Variance of the delay in ms. Defaults to 50.
Examples
--------
Some calling examples. Deep dive into the filter syntax:
https://docs.microsoft.com/en-us/azure/kusto/query/
>>> network_latency("where resourceGroup=='rg'", configuration=c,
secrets=s)
Increase the latency of all machines from the group 'rg'
>>> network_latency("where resourceGroup=='rg' and name='name'",
configuration=c, secrets=s)
Increase the latecy of the machine from the group 'rg' having the name
'name'
>>> network_latency("where resourceGroup=='rg' | sample 2",
configuration=c, secrets=s)
Increase the latency of two machines at random from the group 'rg'
"""
logger.debug(
"Start network_latency: configuration='{}', filter='{}'".format(
configuration, filter))
machines = __fetch_machines(filter, configuration, secrets)
machine_records = Records()
for machine in machines:
command_id, script_content = command \
.prepare(machine, 'network_latency')
logger.debug("Script content: {}".format(script_content))
parameters = {
'command_id':
command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}, {
'name': "delay",
'value': delay
}, {
'name': "jitter",
'value': jitter
}]
}
logger.debug("Increasing the latency of machine: {}".format(
machine['name']))
_timeout = duration + timeout
command.run(machine['resourceGroup'], machine, _timeout, parameters,
secrets, configuration)
machine_records.add(cleanse.machine(machine))
return machine_records.output_as_dict('resources')
def fill_disk(filter: str = None,
duration: int = 120,
timeout: int = 60,
size: int = 1000,
path: str = None,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Fill the disk with random data.
Parameters
----------
filter : str, optional
Filter the virtual machines. If the filter is omitted all machines in
the subscription will be selected as potential chaos candidates.
duration : int, optional
Lifetime of the file created. Defaults to 120 seconds.
timeout : int
Additional wait time (in seconds)
for filling operation to be completed.
Getting and sending data from/to Azure may take some time so it's not
recommended to set this value to less than 30s. Defaults to 60 seconds.
size : int
Size of the file created on the disk. Defaults to 1GB.
path : str, optional
The absolute path to write the fill file into.
Defaults: C:/burn for Windows clients, /root/burn for Linux clients.
Examples
--------
Some calling examples. Deep dive into the filter syntax:
https://docs.microsoft.com/en-us/azure/kusto/query/
>>> fill_disk("where resourceGroup=='rg'", configuration=c, secrets=s)
Fill all machines from the group 'rg'
>>> fill_disk("where resourceGroup=='rg' and name='name'",
configuration=c, secrets=s)
Fill the machine from the group 'rg' having the name 'name'
>>> fill_disk("where resourceGroup=='rg' | sample 2",
configuration=c, secrets=s)
Fill two machines at random from the group 'rg'
"""
msg = "Starting fill_disk: configuration='{}', filter='{}'," \
" duration='{}', size='{}', path='{}', timeout='{}'" \
.format(configuration, filter, duration, size, path, timeout)
logger.debug(msg)
machines = __fetch_machines(filter, configuration, secrets)
machine_records = Records()
for machine in machines:
command_id, script_content = command.prepare(machine, 'fill_disk')
fill_path = command.prepare_path(machine, path)
parameters = {
'command_id':
command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}, {
'name': "size",
'value': size
}, {
'name': "path",
'value': fill_path
}]
}
logger.debug("Filling disk of machine: {}".format(machine['name']))
_timeout = duration + timeout
command.run(machine['resourceGroup'], machine, _timeout, parameters,
secrets, configuration)
machine_records.add(cleanse.machine(machine))
return machine_records.output_as_dict('resources')
def stress_cpu(filter: str = None,
duration: int = 120,
timeout: int = 60,
configuration: Configuration = None,
secrets: Secrets = None):
"""
Stress CPU up to 100% at virtual machines.
Parameters
----------
filter : str, optional
Filter the virtual machines. If the filter is omitted all machines in
the subscription will be selected as potential chaos candidates.
duration : int, optional
Duration of the stress test (in seconds) that generates high CPU usage.
Defaults to 120 seconds.
timeout : int
Additional wait time (in seconds) for stress operation to be completed.
Getting and sending data from/to Azure may take some time so it's not
recommended to set this value to less than 30s. Defaults to 60 seconds.
Examples
--------
Some calling examples. Deep dive into the filter syntax:
https://docs.microsoft.com/en-us/azure/kusto/query/
>>> stress_cpu("where resourceGroup=='rg'", configuration=c, secrets=s)
Stress all machines from the group 'rg'
>>> stress_cpu("where resourceGroup=='rg' and name='name'",
configuration=c, secrets=s)
Stress the machine from the group 'rg' having the name 'name'
>>> stress_cpu("where resourceGroup=='rg' | sample 2",
configuration=c, secrets=s)
Stress two machines at random from the group 'rg'
"""
msg = "Starting stress_cpu:" \
" configuration='{}', filter='{}', duration='{}', timeout='{}'" \
.format(configuration, filter, duration, timeout)
logger.debug(msg)
machines = __fetch_machines(filter, configuration, secrets)
machine_records = Records()
for machine in machines:
command_id, script_content = command \
.prepare(machine, 'cpu_stress_test')
parameters = {
'command_id': command_id,
'script': [script_content],
'parameters': [{
'name': "duration",
'value': duration
}]
}
logger.debug("Stressing CPU of machine: '{}'".format(machine['name']))
_timeout = duration + timeout
command.run(machine['resourceGroup'], machine, _timeout, parameters,
secrets, configuration)
machine_records.add(cleanse.machine(machine))
return machine_records.output_as_dict('resources')
