def delete_machines(filter: str = None, configuration: Configuration = None, secrets: Secrets = None): """ Delete virtual machines at random. **Be aware**: Deleting a machine is an invasive action. You will not be able to recover the machine once you deleted it. 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. Examples -------- Some calling examples. Deep dive into the filter syntax: https://docs.microsoft.com/en-us/azure/kusto/query/ >>> delete_machines("where resourceGroup=='rg'", c, s) Delete all machines from the group 'rg' >>> delete_machines("where resourceGroup=='rg' and name='name'", c, s) Delete the machine from the group 'rg' having the name 'name' >>> delete_machines("where resourceGroup=='rg' | sample 2", c, s) Delete two machines at random from the group 'rg' """ logger.debug("Start delete_machines: " "configuration='{}', filter='{}'".format( configuration, filter)) machines = __fetch_machines(filter, configuration, secrets) client = __compute_mgmt_client(secrets, configuration) machine_records = Records() for m in machines: group = m['resourceGroup'] name = m['name'] logger.debug("Deleting machine: {}".format(name)) client.virtual_machines.delete(group, name) machine_records.add(cleanse.machine(m)) return machine_records.output_as_dict('resources')
def start_machines(filter: str = None, configuration: Configuration = None, secrets: Secrets = None): """ Start virtual machines at random. Thought as a rollback action. 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. Examples -------- Some calling examples. Deep dive into the filter syntax: https://docs.microsoft.com/en-us/azure/kusto/query/ >>> start_machines("where resourceGroup=='rg'", c, s) Start all stopped machines from the group 'rg' >>> start_machines("where resourceGroup=='rg' and name='name'", c, s) Start the stopped machine from the group 'rg' having the name 'name' >>> start_machines("where resourceGroup=='rg' | sample 2", c, s) Start two stopped machines at random from the group 'rg' """ logger.debug( "Start start_machines: configuration='{}', filter='{}'".format( configuration, filter)) machines = __fetch_machines(filter, configuration, secrets) client = __compute_mgmt_client(secrets, configuration) stopped_machines = __fetch_all_stopped_machines(client, machines) machine_records = Records() for machine in stopped_machines: logger.debug("Starting machine: {}".format(machine['name'])) client.virtual_machines.start(machine['resourceGroup'], machine['name']) machine_records.add(cleanse.machine(machine)) return machine_records.output_as_dict('resources')
def stop_machines(filter: str = None, configuration: Configuration = None, secrets: Secrets = None): """ Stop virtual machines at random. 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. Examples -------- Some calling examples. Deep dive into the filter syntax: https://docs.microsoft.com/en-us/azure/kusto/query/ >>> stop_machines("where resourceGroup=='rg'", c, s) Stop all machines from the group 'rg' >>> stop_machines("where resourceGroup=='mygroup' and name='myname'", c, s) Stop the machine from the group 'mygroup' having the name 'myname' >>> stop_machines("where resourceGroup=='mygroup' | sample 2", c, s) Stop two machines at random from the group 'mygroup' """ logger.debug("Start stop_machines: " "configuration='{}', filter='{}'".format( configuration, filter)) machines = __fetch_machines(filter, configuration, secrets) client = __compute_mgmt_client(secrets, configuration) machine_records = Records() for m in machines: group = m['resourceGroup'] name = m['name'] logger.debug("Stopping machine: {}".format(name)) client.virtual_machines.power_off(group, name) machine_records.add(cleanse.machine(m)) return machine_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')