# setup (you can ignore this)
# ###########################
# a bit of setup to allow overriding rpc_interace with an RPC proxy
# (to use RPC, we would say
# import rpc_client_lib
# rpc_interface = rpc_client_lib.get_proxy(
# 'http://hostname:8000/afe/server/noauth/rpc/')
# )
>>> if 'rpc_interface' not in globals():
... from autotest_lib.frontend.afe import rpc_interface, models
... from autotest_lib.frontend import thread_local
... # set up a user for us to "login" as
... user = models.User(login='debug_user')
... user.access_level = 100
... user.save()
... thread_local.set_user(user)
...
>>> from autotest_lib.frontend.afe import model_logic
# get directory of this test file; we'll need it later
>>> import common
>>> from autotest_lib.frontend.afe import test
>>> import os, datetime
>>> test_path = os.path.join(os.path.dirname(test.__file__),
... 'doctests')
>>> test_path = os.path.abspath(test_path)
# disable logging
>>> from autotest_lib.client.common_lib import logging_manager
>>> logging_manager.logger.setLevel(100)
>>> drone_set = models.DroneSet.default_drone_set_name()
>>> if drone_set:
... _ = models.DroneSet.objects.create(name=drone_set)
# mock up tko rpc_interface
>>> from autotest_lib.client.common_lib.test_utils import mock
>>> mock.mock_god().stub_function_to_return(rpc_interface.tko_rpc_interface,
... 'get_status_counts',
... None)
# basic interface test
######################
# echo a comment
>>> rpc_interface.echo('test string to echo')
'test string to echo'
# basic object management
# #######################
# create a label
>>> rpc_interface.add_label(name='test_label')
1
# we can modify the label by referencing its ID...
>>> rpc_interface.modify_label(1, kernel_config='/my/kernel/config')
# ...or by referencing it's name
>>> rpc_interface.modify_label('test_label', platform=True)
# we use get_labels to retrieve object data
>>> data = rpc_interface.get_labels(name='test_label')
>>> data == [{'id': 1,
... 'name': 'test_label',
... 'platform': 1,
... 'kernel_config': '/my/kernel/config',
... 'only_if_needed' : False,
... 'invalid': 0,
... 'atomic_group': None}]
True
# get_labels return multiple matches as lists of dictionaries
>>> rpc_interface.add_label(name='label1', platform=False)
2
>>> rpc_interface.add_label(name='label2', platform=True)
3
>>> rpc_interface.add_label(name='label3', platform=False)
4
>>> data = rpc_interface.get_labels(platform=False)
>>> data == [{'id': 2, 'name': 'label1', 'platform': 0, 'kernel_config': '',
... 'only_if_needed': False, 'invalid': 0, 'atomic_group': None},
... {'id': 4, 'name': 'label3', 'platform': 0, 'kernel_config': '',
... 'only_if_needed': False, 'invalid': 0, 'atomic_group': None}]
True
# delete_label takes an ID or a name as well
>>> rpc_interface.delete_label(3)
>>> rpc_interface.get_labels(name='label2')
[]
>>> rpc_interface.delete_label('test_label')
>>> rpc_interface.delete_label('label1')
>>> rpc_interface.delete_label('label3')
>>> rpc_interface.get_labels()
[]
# all the add*, modify*, delete*, and get* methods work the same way
# hosts...
>>> rpc_interface.add_host(hostname='ipaj1', locked=True, lock_reason='Locked device on creation')
1
>>> data = rpc_interface.get_hosts()
# delete the lock_time field, since that can't be reliably checked
>>> del data[0]['lock_time']
>>> data == [{'id': 1,
... 'hostname': 'ipaj1',
... 'locked': 1,
... 'synch_id': None,
... 'status': 'Ready',
... 'labels': [],
... 'atomic_group': None,
... 'acls': ['Everyone'],
... 'platform': None,
... 'attributes': {},
... 'invalid': 0,
... 'protection': 'No protection',
... 'locked_by': 'debug_user',
... 'dirty': True,
... 'leased': 1,
... 'shard': None,
... 'lock_reason': 'Locked device on creation'}]
True
>>> rpc_interface.modify_host(id='ipaj1', status='Hello')
Traceback (most recent call last):
ValidationError: {'status': 'Host status can not be modified by the frontend.'}
>>> rpc_interface.modify_host(id='ipaj1', hostname='ipaj1000')
>>> rpc_interface.modify_hosts(
... host_filter_data={'hostname': 'ipaj1000'},
... update_data={'locked': False})
>>> data = rpc_interface.get_hosts()
>>> bool(data[0]['locked'])
False
# test already locked/unlocked failures
>>> rpc_interface.modify_host(id='ipaj1000', locked=False)
Traceback (most recent call last):
ValidationError: {'locked': u'Host ipaj1000 already unlocked.'}
>>> rpc_interface.modify_host(id='ipaj1000', locked=True, lock_reason='Locking a locked device')
>>> try:
... rpc_interface.modify_host(id='ipaj1000', locked=True)
... except model_logic.ValidationError, err:
... pass
>>> assert ('locked' in err.message_dict
... and err.message_dict['locked'].startswith('Host ipaj1000 already locked'))
>>> rpc_interface.delete_host(id='ipaj1000')
>>> rpc_interface.get_hosts() == []
True
# tests...
>>> rpc_interface.add_test(name='sleeptest', test_type='Client', author='Test',
... description='Sleep Test', test_time=1,
... test_category='Functional',
... test_class='Kernel', path='sleeptest')
1
>>> rpc_interface.modify_test('sleeptest', path='/my/path')
>>> data = rpc_interface.get_tests()
>>> data == [{'id': 1,
... 'name': 'sleeptest',
... 'author': 'Test',
... 'description': 'Sleep Test',
... 'dependencies': '',
... 'experimental': 1,
... 'sync_count': 1,
... 'test_type': 'Client',
... 'test_class': 'Kernel',
... 'test_time': 'SHORT',
... 'run_verify': 0,
... 'run_reset': 1,
... 'test_category': 'Functional',
... 'path': '/my/path',
... 'test_retry': 0}]
True
>>> rpc_interface.delete_test('sleeptest')
>>> rpc_interface.get_tests() == []
True
# profilers...
>>> rpc_interface.add_profiler(name='oprofile')
1
>>> rpc_interface.modify_profiler('oprofile', description='Oh profile!')
>>> data = rpc_interface.get_profilers()
>>> data == [{'id': 1,
... 'name': 'oprofile',
... 'description': 'Oh profile!'}]
True
>>> rpc_interface.delete_profiler('oprofile')
>>> rpc_interface.get_profilers() == []
True
# users...
>>> rpc_interface.add_user(login='showard')
2
>>> rpc_interface.modify_user('showard', access_level=1)
>>> data = rpc_interface.get_users(login='showard')
>>> data == [{'id': 2,
... 'login': 'showard',
... 'access_level': 1,
... 'reboot_before': 'If dirty',
... 'reboot_after': 'Never',
... 'drone_set': None,
... 'show_experimental': False}]
True
>>> rpc_interface.delete_user('showard')
>>> rpc_interface.get_users(login='showard') == []
True
# acl groups...
# 1 ACL group already exists, named "Everyone" (ID 1)
>>> rpc_interface.add_acl_group(name='my_group')
2
>>> rpc_interface.modify_acl_group('my_group', description='my new acl group')
>>> data = rpc_interface.get_acl_groups(name='my_group')
>>> data == [{'id': 2,
... 'name': 'my_group',
... 'description': 'my new acl group',
... 'users': ['debug_user'],
... 'hosts': []}]
True
>>> rpc_interface.delete_acl_group('my_group')
>>> data = rpc_interface.get_acl_groups()
>>> data == [{'id': 1,
... 'name': 'Everyone',
... 'description': '',
... 'users': ['debug_user'],
... 'hosts': []}]
True
# managing many-to-many relationships
# ###################################
# first, create some hosts and labels to play around with
>>> rpc_interface.add_host(hostname='host1')
2
>>> rpc_interface.add_host(hostname='host2')
3
>>> rpc_interface.add_label(name='label1')
2
>>> rpc_interface.add_label(name='label2', platform=True)
3
# add hosts to labels
>>> rpc_interface.host_add_labels(id='host1', labels=['label1'])
>>> rpc_interface.host_add_labels(id='host2', labels=['label1', 'label2'])
# check labels for hosts
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['labels']
[u'label1']
>>> data = rpc_interface.get_hosts(hostname='host2')
>>> data[0]['labels']
[u'label1', u'label2']
>>> data[0]['platform']
u'label2'
# check host lists for labels -- use double underscore to specify fields of
# related objects
>>> data = rpc_interface.get_hosts(labels__name='label1')
>>> [host['hostname'] for host in data]
[u'host1', u'host2']
>>> data = rpc_interface.get_hosts(labels__name='label2')
>>> [host['hostname'] for host in data]
[u'host2']
# remove a host from a label
>>> rpc_interface.host_remove_labels(id='host2', labels=['label2'])
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['labels']
[u'label1']
>>> rpc_interface.get_hosts(labels__name='label2')
[]
# Cleanup
>>> rpc_interface.host_remove_labels(id='host2', labels=['label1'])
>>> rpc_interface.host_remove_labels(id='host1', labels=['label1'])
# Other interface for new CLI
# add hosts to labels
>>> rpc_interface.label_add_hosts(id='label1', hosts=['host1'])
>>> rpc_interface.label_add_hosts(id='label2', hosts=['host1', 'host2'])
# check labels for hosts
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['labels']
[u'label1', u'label2']
>>> data = rpc_interface.get_hosts(hostname='host2')
>>> data[0]['labels']
[u'label2']
>>> data[0]['platform']
u'label2'
# check host lists for labels -- use double underscore to specify fields of
# related objects
>>> data = rpc_interface.get_hosts(labels__name='label1')
>>> [host['hostname'] for host in data]
[u'host1']
>>> data = rpc_interface.get_hosts(labels__name='label2')
>>> [host['hostname'] for host in data]
[u'host1', u'host2']
# remove a host from a label
>>> rpc_interface.label_remove_hosts(id='label2', hosts=['host2'])
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['labels']
[u'label1', u'label2']
>>> data = rpc_interface.get_hosts(labels__name='label2')
>>> [host['hostname'] for host in data]
[u'host1']
# Remove multiple hosts from a label
>>> rpc_interface.label_add_hosts(id='label2', hosts=['host2'])
>>> data = rpc_interface.get_hosts(labels__name='label2')
>>> [host['hostname'] for host in data]
[u'host1', u'host2']
>>> rpc_interface.label_remove_hosts(id='label2', hosts=['host2', 'host1'])
>>> rpc_interface.get_hosts(labels__name='label2')
[]
# ACL group relationships work similarly
# note that all users are a member of 'Everyone' by default, and that hosts are
# automatically made a member of 'Everyone' only when they are a member of no
# other group
>>> data = rpc_interface.get_acl_groups(hosts__hostname='host1')
>>> [acl_group['name'] for acl_group in data]
[u'Everyone']
>>> rpc_interface.add_user(login='showard', access_level=0)
2
>>> rpc_interface.add_acl_group(name='my_group')
2
>>> rpc_interface.acl_group_add_users('my_group', ['showard'])
>>> rpc_interface.acl_group_add_hosts('my_group', ['host1'])
>>> data = rpc_interface.get_acl_groups(name='my_group')
>>> data[0]['users']
[u'debug_user', u'showard']
>>> data[0]['hosts']
[u'host1']
>>> data = rpc_interface.get_acl_groups(users__login='showard')
>>> [acl_group['name'] for acl_group in data]
[u'Everyone', u'my_group']
# note host has been automatically removed from 'Everyone'
>>> data = rpc_interface.get_acl_groups(hosts__hostname='host1')
>>> [acl_group['name'] for acl_group in data]
[u'my_group']
>>> rpc_interface.acl_group_remove_users('my_group', ['showard'])
>>> rpc_interface.acl_group_remove_hosts('my_group', ['host1'])
>>> data = rpc_interface.get_acl_groups(name='my_group')
>>> data[0]['users'], data[0]['hosts']
([u'debug_user'], [])
>>> data = rpc_interface.get_acl_groups(users__login='showard')
>>> [acl_group['name'] for acl_group in data]
[u'Everyone']
# note host has been automatically added back to 'Everyone'
>>> data = rpc_interface.get_acl_groups(hosts__hostname='host1')
>>> [acl_group['name'] for acl_group in data]
[u'Everyone']
# host attributes
>>> rpc_interface.set_host_attribute('color', 'red', hostname='host1')
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['attributes']
{u'color': u'red'}
>>> rpc_interface.set_host_attribute('color', None, hostname='host1')
>>> data = rpc_interface.get_hosts(hostname='host1')
>>> data[0]['attributes']
{}
# host bulk modify
##################
>>> rpc_interface.modify_hosts(
... host_filter_data={'hostname__in': ['host1', 'host2']},
... update_data={'locked': True, 'lock_reason': 'Locked for testing'})
>>> data = rpc_interface.get_hosts(hostname__in=['host1', 'host2'])
>>> data[0]['locked']
True
>>> data[1]['locked']
True
>>> rpc_interface.modify_hosts(
... host_filter_data={'id': 2},
... update_data={'locked': False})
>>> data = rpc_interface.get_hosts(hostname__in=['host1', 'host2'])
>>> data[0]['locked']
False
>>> data[1]['locked']
True
# job management
# ############
# note that job functions require job IDs to identify jobs, since job names are
# not unique
# add some entries to play with
>>> rpc_interface.add_label(name='my_label', kernel_config='my_kernel_config')
5
>>> test_control_path = os.path.join(test_path, 'test.control')
>>> rpc_interface.add_test(name='sleeptest', test_type='Client', author='Test',
... test_category='Test',
... test_class='Kernel', path=test_control_path)
1
>>> test_control_path = os.path.join(test_path, 'test.control.2')
>>> rpc_interface.add_test(name='my_test', test_type='Client', author='Test',
... test_category='Test',
... test_class='Kernel', path=test_control_path)
2
>>> rpc_interface.add_host(hostname='my_label_host1')
4
>>> rpc_interface.add_host(hostname='my_label_host2')
5
>>> rpc_interface.label_add_hosts(id='my_label', hosts=['my_label_host1', 'my_label_host2'])
# generate a control file
>>> cf_info = rpc_interface.generate_control_file(
... tests=['sleeptest', 'my_test'],
... kernel=[{'version': '2.6.18'}, {'version': '2.6.18-blah.rpm'},
... {'version': '2.6.26', 'cmdline': 'foo bar'}],
... label='my_label')
>>> print cf_info['control_file'] #doctest: +NORMALIZE_WHITESPACE
kernel_list = [{'version': '2.6.18', 'config_file': u'my_kernel_config'}, {'version': '2.6.18-blah.rpm', 'config_file': None}, {'cmdline': 'foo bar', 'version': '2.6.26', 'config_file': u'my_kernel_config'}]
def step_init():
for kernel_info in kernel_list:
job.next_step(boot_kernel, kernel_info)
job.next_step(step_test, kernel_info['version'])
if len(kernel_list) > 1:
job.use_sequence_number = True # include run numbers in directory names
def boot_kernel(kernel_info):
# remove kernels (and associated data) not referenced by the bootloader
for host in job.hosts:
host.cleanup_kernels()
testkernel = job.kernel(kernel_info['version'])
if kernel_info['config_file']:
testkernel.config(kernel_info['config_file'])
testkernel.build()
testkernel.install()
cmdline = ' '.join((kernel_info.get('cmdline', ''), ''))
testkernel.boot(args=cmdline)
def step_test(kernel_version):
global kernel
kernel = kernel_version # Set the global in case anyone is using it.
if len(kernel_list) > 1:
# this is local to a machine, safe to assume there's only one host
host, = job.hosts
job.automatic_test_tag = host.get_kernel_ver()
job.next_step('step0')
job.next_step('step1')
def step0():
job.run_test('testname')
def step1():
job.run_test('testname')
>>> cf_info['is_server'], cf_info['synch_count'], cf_info['dependencies']
(False, 1, [])
# generate a control file from existing body text.
>>> cf_info_pi = rpc_interface.generate_control_file(
... kernel=[{'version': '3.1.41'}], label='my_label',
... client_control_file='print "Hi"\n')
>>> print cf_info_pi['control_file'] #doctest: +NORMALIZE_WHITESPACE
kernel_list = [{'version': '3.1.41', 'config_file': u'my_kernel_config'}]
def step_init():
for kernel_info in kernel_list:
job.next_step(boot_kernel, kernel_info)
job.next_step(step_test, kernel_info['version'])
if len(kernel_list) > 1:
job.use_sequence_number = True # include run numbers in directory names
def boot_kernel(kernel_info):
# remove kernels (and associated data) not referenced by the bootloader
for host in job.hosts:
host.cleanup_kernels()
testkernel = job.kernel(kernel_info['version'])
if kernel_info['config_file']:
testkernel.config(kernel_info['config_file'])
testkernel.build()
testkernel.install()
cmdline = ' '.join((kernel_info.get('cmdline', ''), ''))
testkernel.boot(args=cmdline)
def step_test(kernel_version):
global kernel
kernel = kernel_version # Set the global in case anyone is using it.
if len(kernel_list) > 1:
# this is local to a machine, safe to assume there's only one host
host, = job.hosts
job.automatic_test_tag = host.get_kernel_ver()
job.next_step('step0')
def step0():
print "Hi"
return locals()
# create a job to run on host1, host2, and any two machines in my_label
>>> rpc_interface.create_job(name='my_job',
... priority=10,
... control_file=cf_info['control_file'],
... control_type='Client',
... hosts=['host1', 'host2'],
... meta_hosts=['my_label', 'my_label'])
1
# get job info - this does not include status info for particular hosts
>>> data = rpc_interface.get_jobs()
>>> data = data[0]
>>> data['id'], data['owner'], data['name'], data['priority']
(1, u'debug_user', u'my_job', 10)
>>> data['control_file'] == cf_info['control_file']
True
>>> data['control_type']
'Client'
>>> today = datetime.date.today()
>>> data['created_on'].startswith(
... '%d-%02d-%02d' % (today.year, today.month, today.day))
True
# get_num_jobs - useful when dealing with large numbers of jobs
>>> rpc_interface.get_num_jobs(name='my_job')
1
# check host queue entries for a job
>>> data = rpc_interface.get_host_queue_entries(job=1)
>>> len(data)
4
# get rid of created_on, it's nondeterministic
>>> data[0]['job']['created_on'] = data[2]['job']['created_on'] = None
# get_host_queue_entries returns full info about the job within each queue entry
>>> job = data[0]['job']
>>> job == {'control_file': cf_info['control_file'], # the control file we used
... 'control_type': 'Client',
... 'created_on': None,
... 'id': 1,
... 'name': 'my_job',
... 'owner': 'debug_user',
... 'priority': 10,
... 'synch_count': 0,
... 'timeout': 24,
... 'timeout_mins': 1440,
... 'max_runtime_mins': 1440,
... 'max_runtime_hrs' : 72,
... 'run_verify': False,
... 'run_reset': True,
... 'email_list': '',
... 'reboot_before': 'If dirty',
... 'reboot_after': 'Never',
... 'parse_failed_repair': True,
... 'drone_set': drone_set,
... 'parameterized_job': None,
... 'test_retry': 0,
... 'parent_job': None,
... 'shard': None,
... 'require_ssp': None}
True
# get_host_queue_entries returns a lot of data, so let's only check a couple
>>> data[0] == (
... {'active': 0,
... 'complete': 0,
... 'host': {'hostname': 'host1', # full host info here
... 'id': 2,
... 'invalid': 0,
... 'locked': 0,
... 'status': 'Ready',
... 'synch_id': None,
... 'protection': 'No protection',
... 'locked_by': None,
... 'lock_time': None,
... 'lock_reason': 'Locked for testing',
... 'dirty': True,
... 'leased': 1,
... 'shard': None},
... 'id': 1,
... 'job': job, # full job info here
... 'meta_host': None,
... 'status': 'Queued',
... 'deleted': 0,
... 'execution_subdir': '',
... 'atomic_group': None,
... 'aborted': False,
... 'started_on': None,
... 'finished_on': None,
... 'full_status': 'Queued'})
True
>>> data[2] == (
... {'active': 0,
... 'complete': 0,
... 'host': None,
... 'id': 3,
... 'job': job,
... 'meta_host': 'my_label',
... 'status': 'Queued',
... 'deleted': 0,
... 'execution_subdir': '',
... 'atomic_group': None,
... 'aborted': False,
... 'started_on': None,
... 'finished_on': None,
... 'full_status': 'Queued'})
True
>>> rpc_interface.get_num_host_queue_entries(job=1)
4
>>> rpc_interface.get_hqe_percentage_complete(job=1)
0.0
# get_jobs_summary adds status counts to the rest of the get_jobs info
>>> data = rpc_interface.get_jobs_summary()
>>> counts = data[0]['status_counts']
>>> counts
{u'Queued': 4}
# abort the job
>>> data = rpc_interface.abort_host_queue_entries(job__id=1)
>>> data = rpc_interface.get_jobs_summary(id=1)
>>> data[0]['status_counts']
{u'Aborted (Queued)': 4}
# Remove the two hosts in my_label
>>> rpc_interface.delete_host(id='my_label_host1')
>>> rpc_interface.delete_host(id='my_label_host2')
# extra querying parameters
# #########################
# get_* methods can take query_start and query_limit arguments to implement
# paging and a sort_by argument to specify the sort column
>>> data = rpc_interface.get_hosts(query_limit=1)
>>> [host['hostname'] for host in data]
[u'host1']
>>> data = rpc_interface.get_hosts(query_start=1, query_limit=1)
>>> [host['hostname'] for host in data]
[u'host2']
# sort_by = ['-hostname'] indicates sorting in descending order by hostname
>>> data = rpc_interface.get_hosts(sort_by=['-hostname'])
>>> [host['hostname'] for host in data]
[u'host2', u'host1']
# cloning a job
# #############
>>> job_id = rpc_interface.create_job(name='my_job_to_clone',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Client',
... hosts=['host2'],
... synch_count=1)
>>> info = rpc_interface.get_info_for_clone(job_id, False)
>>> info['atomic_group_name']
>>> info['meta_host_counts']
{}
>>> info['job']['dependencies']
[]
>>> info['job']['priority']
50
# advanced usage
# ##############
# synch_count
>>> job_id = rpc_interface.create_job(name='my_job',
... priority=10,
... control_file=cf_info['control_file'],
... control_type='Server',
... synch_count=2,
... hosts=['host1', 'host2'])
>>> data = rpc_interface.get_jobs(id=job_id)
>>> data[0]['synch_count']
2
# get hosts ACL'd to a user
>>> hosts = rpc_interface.get_hosts(aclgroup__users__login='debug_user')
>>> sorted([host['hostname'] for host in hosts])
[u'host1', u'host2']
>>> rpc_interface.add_acl_group(name='mygroup')
3
>>> rpc_interface.acl_group_add_users('mygroup', ['debug_user'])
>>> rpc_interface.acl_group_add_hosts('mygroup', ['host1'])
>>> data = rpc_interface.get_acl_groups(name='Everyone')[0]
>>> data['users'], data['hosts']
([u'debug_user', u'showard'], [u'host2'])
>>> data = rpc_interface.get_acl_groups(name='mygroup')[0]
>>> data['users'], data['hosts']
([u'debug_user'], [u'host1'])
>>> hosts = rpc_interface.get_hosts(aclgroup__users__login='debug_user')
>>> sorted([host['hostname'] for host in hosts])
[u'host1', u'host2']
>>> hosts = rpc_interface.get_hosts(aclgroup__users__login='showard')
>>> [host['hostname'] for host in hosts]
[u'host2']
>>> rpc_interface.delete_acl_group('mygroup')
>>> data = rpc_interface.get_acl_groups(name='Everyone')[0]
>>> sorted(data['hosts'])
[u'host1', u'host2']
# atomic groups
# #############
# Add an atomic group and associate some labels and new hosts with it.
>>> mini_rack_group_id = rpc_interface.add_atomic_group(
... name='mini rack',
... max_number_of_machines=10,
... description='a partial rack-o-machines')
>>> label_id = rpc_interface.add_label(name='one-label')
>>> rpc_interface.modify_label(label_id, atomic_group='mini rack')
>>> labels = rpc_interface.get_labels(id=label_id)
>>> assert labels[0]['atomic_group']['id'] == mini_rack_group_id, labels
>>> rpc_interface.modify_label(label_id, atomic_group=None)
>>> labels = rpc_interface.get_labels(id=label_id)
>>> assert not labels[0]['atomic_group'], labels
>>> rpc_interface.modify_label(label_id, atomic_group='mini rack')
>>> labels = rpc_interface.get_labels(id=label_id)
>>> assert labels[0]['atomic_group']['id'] == mini_rack_group_id, labels
>>> data = rpc_interface.get_labels(atomic_group__name='mini rack')
>>> assert len(data) == 1
>>> assert data[0]['name'] == 'one-label', data
>>> assert data[0]['atomic_group']['id'] == mini_rack_group_id, data
>>> data = rpc_interface.get_atomic_groups()
>>> assert len(data) == 1
>>> assert data[0]['id'] == mini_rack_group_id, data
>>> assert data[0]['max_number_of_machines'] == 10, data
>>> assert data[0]['description'] == 'a partial rack-o-machines', data
>>> rpc_interface.modify_atomic_group(1, max_number_of_machines=8)
>>> data = rpc_interface.get_atomic_groups()
>>> assert data[0]['max_number_of_machines'] == 8, data
>>> unused = rpc_interface.add_host(hostname='ahost1')
>>> unused = rpc_interface.add_host(hostname='ahost2')
>>> unused = rpc_interface.add_host(hostname='ah3-blue')
>>> unused = rpc_interface.add_host(hostname='ah4-blue')
>>> two_id = rpc_interface.add_label(name='two-label')
>>> rpc_interface.label_add_hosts(
... id=two_id, hosts=['ahost1', 'ahost2', 'ah3-blue', 'ah4-blue'])
>>> unused = rpc_interface.add_label(name='red-label')
>>> blue_id = rpc_interface.add_label(name='blue-label')
>>> rpc_interface.label_add_hosts(id=blue_id, hosts=['ah3-blue', 'ah4-blue'])
>>> rpc_interface.atomic_group_add_labels(mini_rack_group_id,
... ['one-label', 'two-label',
... 'red-label'])
>>> ag_labels = rpc_interface.get_labels(atomic_group__name='mini rack')
>>> len(ag_labels)
3
>>> hosts_in_two = rpc_interface.get_hosts(multiple_labels=['two-label'])
>>> list(sorted(h['hostname'] for h in hosts_in_two))
[u'ah3-blue', u'ah4-blue', u'ahost1', u'ahost2']
>>> rpc_interface.atomic_group_remove_labels(mini_rack_group_id, ['red-label'])
>>> ag_labels = rpc_interface.get_labels(atomic_group__name='mini rack')
>>> sorted(label['name'] for label in ag_labels)
[u'one-label', u'two-label']
>>> host_list = rpc_interface.get_hosts()
>>> hosts_by_name = {}
>>> for host in host_list:
... hosts_by_name[host['hostname']] = host
...
>>> hosts_by_name['host1']['atomic_group']
>>> hosts_by_name['ahost1']['atomic_group']
u'mini rack'
>>> hosts_by_name['ah3-blue']['atomic_group']
u'mini rack'
>>> host_list = rpc_interface.get_hosts(labels__atomic_group__name='mini rack')
>>> list(sorted(h['hostname'] for h in host_list))
[u'ah3-blue', u'ah4-blue', u'ahost1', u'ahost2']
## Test creation of a job in an atomic group without specifying any
## hosts or meta_hosts.
>>> sleep_cf_info = rpc_interface.generate_control_file(
... tests=['sleeptest'], kernel=[{'version': '2.6.18'}],
... label='two-label')
>>> job_id = rpc_interface.create_job(
... name='atomic_sleeptest', priority=30,
... control_file=sleep_cf_info['control_file'],
... control_type='Server', synch_count=1,
... atomic_group_name='mini rack')
## Test creation of a job in an atomic group by specifying the atomic group
## name as a meta_host rather than explicitly using the atomic_group_name
## parameter.
>>> job_id = rpc_interface.create_job(
... name='atomic_sleeptest', priority=30,
... control_file=sleep_cf_info['control_file'],
... control_type='Server', synch_count=1,
... meta_hosts=['mini rack'])
>>> job_id = rpc_interface.create_job(
... name='atomic_sleeptest', priority=30,
... control_file=sleep_cf_info['control_file'],
... control_type='Server', synch_count=1,
... meta_hosts=['mini rack'],
... atomic_group_name='Different')
Traceback (most recent call last):
ValidationError: {'meta_hosts': 'Label "mini rack" not found. If assumed to be an atomic group it would conflict with the supplied atomic group "Different".'}
## Test job creation with an atomic group.
# fail to create a job in an atomic group. one_time_hosts not allowed.
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... one_time_hosts=['hostX', 'hostY'],
... synch_count=2,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'one_time_hosts': 'One time hosts cannot be used with an Atomic Group.'}
# fail to create a job in an atomic group. Synch count larger than max
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... synch_count=25,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'atomic_group_name': 'You have requested a synch_count (25) greater than the maximum machines in the requested Atomic Group (8).'}
# fail to create a job in an atomic group. not enough hosts due to host list.
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... hosts=['ahost1', 'ahost2'],
... synch_count=3,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'hosts': 'only 2 hosts provided for job with synch_count = 3'}
# fail to create a job in an atomic group. hosts not in atomic group.
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... hosts=['host1', 'host2'],
... synch_count=2,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'hosts': u'Hosts "host1, host2" are not in Atomic Group "mini rack"'}
# fail to create a job in an atomic group. not enough hosts due to meta_hosts.
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... meta_hosts=['blue-label'],
... synch_count=4,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'atomic_group_name': u'Insufficient hosts in Atomic Group "mini rack" with the supplied dependencies and meta_hosts.'}
# fail to create a job in an atomic group. not enough hosts.
>>> rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... synch_count=5,
... atomic_group_name='mini rack')
Traceback (most recent call last):
ValidationError: {'atomic_group_name': u'Insufficient hosts in Atomic Group "mini rack" with the supplied dependencies and meta_hosts.'}
# create a job in an atomic group.
>>> job_id = rpc_interface.create_job(name='my_atomic_job',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Server',
... hosts=['ahost1', 'ahost2'],
... meta_hosts=['blue-label'],
... synch_count=4,
... atomic_group_name='mini rack')
>>> data = rpc_interface.get_host_queue_entries(job__id=job_id)
>>> data[0]['atomic_group']['id']
1
# create a job using hosts in an atomic group but forget to specify the group.
>>> rpc_interface.create_job(name='poke_foo',
... priority=10,
... control_file=cf_info['control_file'],
... control_type='Client',
... hosts=['ahost1', 'ahost2'])
Traceback (most recent call last):
ValidationError: {'hosts': u'Host(s) "ahost1, ahost2" are atomic group hosts but no atomic group was specified for this job.'}
# Create a job using a label in an atomic group as the meta-host but forget
# to specify the group. The frontend should figure this out for us.
>>> job_id = rpc_interface.create_job(name='created_without_explicit_ag',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Client',
... meta_hosts=['two-label'])
>>> job_id = rpc_interface.create_job(
... name='atomic_sleeptest', priority=30,
... control_file=sleep_cf_info['control_file'],
... control_type='Server', synch_count=1,
... meta_hosts=['two-label'],
... dependencies=['blue-label'])
>>> peon_user = models.User(login='peon_user')
>>> peon_user.access_level = 0
>>> from autotest_lib.client.common_lib.test_utils import mock
>>> god = mock.mock_god()
>>> god.stub_function(models.User, "current_user")
>>> models.User.current_user.expect_call().and_return(peon_user)
>>> rpc_interface.abort_host_queue_entries(job__id=job_id)
Traceback (most recent call last):
AclAccessViolation: You cannot abort the following job entries: 8-debug_user/two-label
>>> god.check_playback()
>>> god.unstub_all()
>>> rpc_interface.create_job(name='never_run2',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Client',
... meta_hosts=['blue-label'],
... dependencies=['two-label'])
Traceback (most recent call last):
ValidationError: {'atomic_group_name': "Dependency u'two-label' requires an atomic group but no atomic_group_name or meta_host in an atomic group was specified for this job."}
>>> invisible_group_id = rpc_interface.add_atomic_group(
... name='invisible rack',
... max_number_of_machines=3,
... description='a hidden rack-o-machines')
>>> rpc_interface.atomic_group_add_labels(invisible_group_id,
... ['blue-label'])
>>> rpc_interface.create_job(name='never_run3',
... priority=50,
... control_file=cf_info['control_file'],
... control_type='Client',
... meta_hosts=['two-label'],
... atomic_group_name='invisible rack')
Traceback (most recent call last):
ValidationError: {'atomic_group_name': "meta_hosts or dependency u'two-label' requires atomic group u'mini rack' instead of the supplied atomic_group_name=u'invisible rack'."}
# we're done testing atomic groups, clean up
>>> rpc_interface.delete_atomic_group(invisible_group_id)
>>> rpc_interface.delete_atomic_group(mini_rack_group_id)
>>> assert len(rpc_interface.get_atomic_groups()) == 0