def network_latency(filter: str = None, duration: int = 60, delay: int = 200, jitter: int = 50, network_interface: str = "eth0", configuration: Configuration = None, secrets: Secrets = None): """Increases the response time of the virtual machine. **Please note**: This action is available only for Linux-based systems. Parameters ---------- filter : str, optional Filter the virtual machine instance(s). If omitted a random instance from your subscription is selected. duration : int, optional How long the latency lasts. Defaults to 60 seconds. delay : int, optional Applied delay of the response time in milliseconds. Defaults to 200 milliseconds. jitter : int, optional Applied variance of +/- jitter to the delay of the response time in milliseconds. Defaults to 50 milliseconds. network_interface : str, optional The network interface where the network latency is applied to. Defaults to local ethernet eth0. """ operation_name = network_latency.__name__ logger.debug( "Starting {}: configuration='{}', filter='{}', duration='{}'," " delay='{}', jitter='{}', network_interface='{}'".format( operation_name, configuration, filter, duration, delay, jitter, network_interface)) machines = fetch_machines(filter, configuration, secrets) clnt = client.init() machine_records = Records() futures = [] with concurrent.futures.ThreadPoolExecutor(max_workers=len(machines)) as executor: for machine in machines: command_id, script_content = command.prepare(machine, operation_name) logger.debug("Script content: {}".format(script_content)) parameters = command.fill_parameters( command_id, script_content, duration=duration, delay=delay, jitter=jitter, network_interface=network_interface) # collect future results futures.append( executor.submit(__long_poll_command, operation_name, machine, parameters, clnt)) # wait for results for future in concurrent.futures.as_completed(futures): affected_machine = future.result() machine_records.add(cleanse.machine(affected_machine)) return machine_records.output_as_dict('resources')
def fill_disk(filter: str = None, duration: int = 120, 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 machine instance(s). If omitted a random instance from your subscription is selected. duration : int, optional Lifetime of the file created. Defaults to 120 seconds. size : int Size of the file in megabytes created on the disk. Defaults to 1000 MB. path : str, optional The absolute path to write the fill file into. Defaults to ``C:\\burn`` for Windows clients and ``/root/burn`` for Linux clients. """ logger.debug("Starting {}: configuration='{}', filter='{}', duration='{}', size='{}', path='{}'".format( fill_disk.__name__, configuration, filter, duration, size, path)) machines = fetch_machines(filter, configuration, secrets) clnt = client.init() machine_records = Records() futures = [] with concurrent.futures.ThreadPoolExecutor(max_workers=len(machines)) as executor: for machine in machines: command_id, script_content = command.prepare(machine, 'fill_disk') fill_path = command.prepare_path(machine, path) parameters = command.fill_parameters( command_id, script_content, duration=duration, size=size, path=fill_path) # collect future results futures.append( executor.submit(__long_poll_command, fill_disk.__name__, machine, parameters, clnt)) # wait for results for future in concurrent.futures.as_completed(futures): affected_machine = future.result() machine_records.add(cleanse.machine(affected_machine)) return machine_records.output_as_dict('resources')
def burn_io(filter: str = None, duration: int = 60, path: str = None, configuration: Configuration = None, secrets: Secrets = None): """Simulate heavy disk I/O operations. Parameters ---------- filter : str, optional Filter the virtual machines. If omitted a random instance from your subscription is selected. duration : int, optional How long the burn lasts. Defaults to 60 seconds. path : str, optional The absolute path to write the stress file into. Defaults to ``C:\\burn`` for Windows clients and ``/root/burn`` for Linux clients. """ logger.debug( "Starting {}: configuration='{}', filter='{}', duration='{}',".format( burn_io.__name__, configuration, filter, duration)) machines = fetch_machines(filter, configuration, secrets) clnt = client.init() machine_records = Records() futures = [] with concurrent.futures.ThreadPoolExecutor(max_workers=len(machines)) as executor: for machine in machines: command_id, script_content = command.prepare(machine, 'burn_io') fill_path = command.prepare_path(machine, path) parameters = command.fill_parameters(command_id, script_content, duration=duration, path=fill_path) # collect future results futures.append( executor.submit(__long_poll_command, burn_io.__name__, machine, parameters, clnt)) # wait for results for future in concurrent.futures.as_completed(futures): affected_machine = future.result() machine_records.add(cleanse.machine(affected_machine)) return machine_records.output_as_dict('resources')
def stress_cpu(filter: str = None, duration: int = 120, configuration: Configuration = None, secrets: Secrets = None): """Stress CPU up to 100% at virtual machines. Parameters ---------- filter : str, optional Filter the virtual machine instance(s). If omitted a random instance from your subscription is selected. duration : int, optional Duration of the stress test (in seconds) that generates high CPU usage. Defaults to 120 seconds. """ operation_name = stress_cpu.__name__ logger.debug( "Starting {}: configuration='{}', filter='{}', duration='{}'".format( operation_name, configuration, filter, duration)) machines = fetch_machines(filter, configuration, secrets) clnt = client.init() machine_records = Records() futures = [] with concurrent.futures.ThreadPoolExecutor(max_workers=len(machines)) as executor: for machine in machines: command_id, script_content = command.prepare(machine, operation_name) parameters = command.fill_parameters(command_id, script_content, duration=duration) # collect future results futures.append( executor.submit(__long_poll_command, operation_name, machine, parameters, clnt)) # wait for results for future in concurrent.futures.as_completed(futures): affected_machine = future.result() machine_records.add(cleanse.machine(affected_machine)) return machine_records.output_as_dict('resources')
def delete(filter: str = None, configuration: Configuration = None, secrets: Secrets = None): """Delete virtual machine instance(s). **Be aware**: Deleting a machine instance is an invasive action. You will not be able to recover the machine instance once you deleted it. Parameters ---------- filter : str, optional Filter the virtual machine instance(s). If omitted a random instance from your subscription is selected. """ logger.debug( "Starting {}: configuration='{}', filter='{}'".format(delete.__name__, configuration, filter)) machines = fetch_machines(filter, configuration, secrets) clnt = client.init() machine_records = Records() futures = [] with concurrent.futures.ThreadPoolExecutor(max_workers=len(machines)) as executor: for machine in machines: logger.debug("Deleting machine: {}".format(machine['name'])) try: poller = clnt.virtual_machines.begin_delete(machine['resourceGroup'], machine['name']) except HttpResponseError as e: raise FailedActivity(e.message) # collect future results futures.append(executor.submit(__long_poll, delete.__name__, machine, poller, configuration)) # wait for results for future in concurrent.futures.as_completed(futures): affected_machine = future.result() machine_records.add(cleanse.machine(affected_machine)) return machine_records.output_as_dict('resources')