| # Copyright 2014 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """ |
| The server module contains the objects and methods used to manage servers in |
| Autotest. |
| |
| The valid actions are: |
| list: list all servers in the database |
| create: create a server |
| delete: deletes a server |
| modify: modify a server's role or status. |
| |
| The common options are: |
| --role / -r: role that's related to server actions. |
| |
| See topic_common.py for a High Level Design and Algorithm. |
| """ |
| |
| import common |
| |
| from autotest_lib.cli import action_common |
| from autotest_lib.cli import topic_common |
| from autotest_lib.client.common_lib import error |
| # The django setup is moved here as test_that uses sqlite setup. If this line |
| # is in server_manager, test_that unittest will fail. |
| from autotest_lib.frontend import setup_django_environment |
| from autotest_lib.site_utils import server_manager |
| from autotest_lib.site_utils import server_manager_utils |
| |
| |
| class server(topic_common.atest): |
| """Server class |
| |
| atest server [list|create|delete|modify] <options> |
| """ |
| usage_action = '[list|create|delete|modify]' |
| topic = msg_topic = 'server' |
| msg_items = '<server>' |
| |
| def __init__(self, hostname_required=True): |
| """Add to the parser the options common to all the server actions. |
| |
| @param hostname_required: True to require the command has hostname |
| specified. Default is True. |
| """ |
| super(server, self).__init__() |
| |
| self.parser.add_option('-r', '--role', |
| help='Name of a role', |
| type='string', |
| default=None, |
| metavar='ROLE') |
| self.parser.add_option('-x', '--action', |
| help=('Set to True to apply actions when role ' |
| 'or status is changed, e.g., restart ' |
| 'scheduler when a drone is removed.'), |
| action='store_true', |
| default=False, |
| metavar='ACTION') |
| |
| self.topic_parse_info = topic_common.item_parse_info( |
| attribute_name='hostname', use_leftover=True) |
| |
| self.hostname_required = hostname_required |
| |
| |
| def parse(self): |
| """Parse command arguments. |
| """ |
| role_info = topic_common.item_parse_info(attribute_name='role') |
| kwargs = {} |
| if self.hostname_required: |
| kwargs['req_items'] = 'hostname' |
| (options, leftover) = super(server, self).parse([role_info], **kwargs) |
| if options.web_server: |
| self.invalid_syntax('Server actions will access server database ' |
| 'defined in your local global config. It does ' |
| 'not rely on RPC, no autotest server needs to ' |
| 'be specified.') |
| |
| # self.hostname is a list. Action on server only needs one hostname at |
| # most. |
| if ((not self.hostname and self.hostname_required) or |
| len(self.hostname) > 1): |
| self.invalid_syntax('`server` topic can only manipulate 1 server. ' |
| 'Use -h to see available options.') |
| if self.hostname: |
| # Override self.hostname with the first hostname in the list. |
| self.hostname = self.hostname[0] |
| self.role = options.role |
| return (options, leftover) |
| |
| |
| def output(self, results): |
| """Display output. |
| |
| For most actions, the return is a string message, no formating needed. |
| |
| @param results: return of the execute call. |
| """ |
| print results |
| |
| |
| class server_help(server): |
| """Just here to get the atest logic working. Usage is set by its parent. |
| """ |
| pass |
| |
| |
| class server_list(action_common.atest_list, server): |
| """atest server list [--role <role>]""" |
| |
| def __init__(self): |
| """Initializer. |
| """ |
| super(server_list, self).__init__(hostname_required=False) |
| self.parser.add_option('-t', '--table', |
| help=('List details of all servers in a table, ' |
| 'e.g., \tHostname | Status | Roles | ' |
| 'note\t\tserver1 | primary | scheduler | ' |
| 'lab'), |
| action='store_true', |
| default=False, |
| metavar='TABLE') |
| self.parser.add_option('-s', '--status', |
| help='Only show servers with given status', |
| type='string', |
| default=None, |
| metavar='STATUS') |
| self.parser.add_option('-u', '--summary', |
| help=('Show the summary of roles and status ' |
| 'only, e.g.,\tscheduler: server1(primary) ' |
| 'server2(backup)\t\tdrone: server3(primary' |
| ') server4(backup)'), |
| action='store_true', |
| default=False, |
| metavar='SUMMARY') |
| |
| |
| def parse(self): |
| """Parse command arguments. |
| """ |
| (options, leftover) = super(server_list, self).parse() |
| self.table = options.table |
| self.status = options.status |
| self.summary = options.summary |
| if self.table and self.summary: |
| self.invalid_syntax('Option --table and --summary cannot be both ' |
| 'specified.') |
| return (options, leftover) |
| |
| |
| def execute(self): |
| """Execute the command. |
| |
| @return: A list of servers matched given hostname and role. |
| """ |
| try: |
| return server_manager_utils.get_servers(hostname=self.hostname, |
| role=self.role, |
| status=self.status) |
| except (server_manager_utils.ServerActionError, |
| error.InvalidDataError) as e: |
| self.failure(e, what_failed='Failed to find servers', |
| item=self.hostname, fatal=True) |
| |
| |
| def output(self, results): |
| """Display output. |
| |
| @param results: return of the execute call, a list of server object that |
| contains server information. |
| """ |
| if not results: |
| self.failure('No server is found.', |
| what_failed='Failed to find servers', |
| item=self.hostname, fatal=True) |
| else: |
| print server_manager_utils.get_server_details(results, self.table, |
| self.summary) |
| |
| |
| class server_create(server): |
| """atest server create hostname --role <role> --note <note> |
| """ |
| |
| def __init__(self): |
| """Initializer. |
| """ |
| super(server_create, self).__init__() |
| self.parser.add_option('-n', '--note', |
| help='note of the server', |
| type='string', |
| default=None, |
| metavar='NOTE') |
| |
| |
| def parse(self): |
| """Parse command arguments. |
| """ |
| (options, leftover) = super(server_create, self).parse() |
| self.note = options.note |
| |
| if not self.role: |
| self.invalid_syntax('--role is required to create a server.') |
| |
| return (options, leftover) |
| |
| |
| def execute(self): |
| """Execute the command. |
| |
| @return: A Server object if it is created successfully. |
| """ |
| try: |
| return server_manager.create(hostname=self.hostname, role=self.role, |
| note=self.note) |
| except (server_manager_utils.ServerActionError, |
| error.InvalidDataError) as e: |
| self.failure(e, what_failed='Failed to create server', |
| item=self.hostname, fatal=True) |
| |
| |
| def output(self, results): |
| """Display output. |
| |
| @param results: return of the execute call, a server object that |
| contains server information. |
| """ |
| if results: |
| print 'Server %s is added to server database:\n' % self.hostname |
| print results |
| |
| |
| class server_delete(server): |
| """atest server delete hostname""" |
| |
| def execute(self): |
| """Execute the command. |
| |
| @return: True if server is deleted successfully. |
| """ |
| try: |
| server_manager.delete(hostname=self.hostname) |
| return True |
| except (server_manager_utils.ServerActionError, |
| error.InvalidDataError) as e: |
| self.failure(e, what_failed='Failed to delete server', |
| item=self.hostname, fatal=True) |
| |
| |
| def output(self, results): |
| """Display output. |
| |
| @param results: return of the execute call. |
| """ |
| if results: |
| print ('Server %s is deleted from server database successfully.' % |
| self.hostname) |
| |
| |
| class server_modify(server): |
| """atest server modify hostname |
| |
| modify action can only change one input at a time. Available inputs are: |
| --status: Status of the server. |
| --note: Note of the server. |
| --role: New role to be added to the server. |
| --delete_role: Existing role to be deleted from the server. |
| """ |
| |
| def __init__(self): |
| """Initializer. |
| """ |
| super(server_modify, self).__init__() |
| self.parser.add_option('-s', '--status', |
| help='Status of the server', |
| type='string', |
| metavar='STATUS') |
| self.parser.add_option('-n', '--note', |
| help='Note of the server', |
| type='string', |
| default=None, |
| metavar='NOTE') |
| self.parser.add_option('-d', '--delete', |
| help=('Set to True to delete given role.'), |
| action='store_true', |
| default=False, |
| metavar='DELETE') |
| self.parser.add_option('-a', '--attribute', |
| help='Name of the attribute of the server', |
| type='string', |
| default=None, |
| metavar='ATTRIBUTE') |
| self.parser.add_option('-e', '--value', |
| help='Value for the attribute of the server', |
| type='string', |
| default=None, |
| metavar='VALUE') |
| |
| |
| def parse(self): |
| """Parse command arguments. |
| """ |
| (options, leftover) = super(server_modify, self).parse() |
| self.status = options.status |
| self.note = options.note |
| self.delete = options.delete |
| self.attribute = options.attribute |
| self.value = options.value |
| self.action = options.action |
| |
| # modify supports various options. However, it's safer to limit one |
| # option at a time so no complicated role-dependent logic is needed |
| # to handle scenario that both role and status are changed. |
| # self.parser is optparse, which does not have function in argparse like |
| # add_mutually_exclusive_group. That's why the count is used here. |
| flags = [self.status is not None, self.role is not None, |
| self.attribute is not None, self.note is not None] |
| if flags.count(True) != 1: |
| msg = ('Action modify only support one option at a time. You can ' |
| 'try one of following 5 options:\n' |
| '1. --status: Change server\'s status.\n' |
| '2. --note: Change server\'s note.\n' |
| '3. --role with optional -d: Add/delete role from server.\n' |
| '4. --attribute --value: Set/change the value of a ' |
| 'server\'s attribute.\n' |
| '5. --attribute -d: Delete the attribute from the ' |
| 'server.\n' |
| '\nUse option -h to see a complete list of options.') |
| self.invalid_syntax(msg) |
| if (self.status != None or self.note != None) and self.delete: |
| self.invalid_syntax('--delete does not apply to status or note.') |
| if self.attribute != None and not self.delete and self.value == None: |
| self.invalid_syntax('--attribute must be used with option --value ' |
| 'or --delete.') |
| return (options, leftover) |
| |
| |
| def execute(self): |
| """Execute the command. |
| |
| @return: The updated server object if it is modified successfully. |
| """ |
| try: |
| return server_manager.modify(hostname=self.hostname, role=self.role, |
| status=self.status, delete=self.delete, |
| note=self.note, |
| attribute=self.attribute, |
| value=self.value, action=self.action) |
| except (server_manager_utils.ServerActionError, |
| error.InvalidDataError) as e: |
| self.failure(e, what_failed='Failed to modify server', |
| item=self.hostname, fatal=True) |
| |
| |
| def output(self, results): |
| """Display output. |
| |
| @param results: return of the execute call, which is the updated server |
| object. |
| """ |
| if results: |
| print 'Server %s is modified successfully.' % self.hostname |
| print results |