def SHOW_CLUSTER_CONTROLLER_SERVICES(connection,
                                     ccs=None,
                                     print_method=None,
                                     print_table=True):
    print_method = print_method or connection._show_method
    hostname_hdr = ('HOSTNAME', 24)
    name_hdr = ('NAME', 24)
    cluster_hdr = ('CLUSTER', 24)
    state_hdr = ('STATE', 16)
    pt = PrettyTable(
        [hostname_hdr[0], name_hdr[0], cluster_hdr[0], state_hdr[0]])
    pt.max_width[hostname_hdr[0]] = hostname_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.max_width[cluster_hdr[0]] = cluster_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.align = 'l'
    pt.padding_width = 0
    if ccs is None:
        ccs = connection.get_all_cluster_controller_services()
    if not isinstance(ccs, list):
        ccs = [ccs]
    for cc in ccs:
        if cc.state == 'ENABLED':
            state = markup(cc.state, [1, 92])
        else:
            state = markup(cc.state, [1, 91])
        pt.add_row(
            [markup(cc.hostname, [1, 94]), cc.name, cc.partition, state])
    if print_table:
        print_method('\n' + pt.get_string(sortby=cluster_hdr[0]) + '\n')
    else:
        return pt
    def show_all_accounts(self, account=None, account_name=None, account_id=None, search=False,
                          print_method=None, print_table=True):
        """
        Debug Method to print an account list based on given filter criteria

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for account_id
        :param search: boolean - specify whether to use match or search when filtering the
                       returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable([markup('ACCOUNT_NAME'), markup('ACCOUNT_ID')])
        pt.hrules = 1
        pt.align = 'l'
        if account:
            if isinstance(account, IamAccount):
                alist = [account]
            else:
                alist = [self.get_account(account)]
        else:
            alist = self.get_all_accounts(account_name=account_name,
                                          account_id=account_id,
                                          search=search)
        for account in alist:
            pt.add_row([account.name, account.id])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
Exemple #3
0
    def show_all_accounts(self,
                          account=None,
                          account_name=None,
                          account_id=None,
                          search=False,
                          print_method=None,
                          print_table=True):
        """
        Debug Method to print an account list based on given filter criteria

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for account_id
        :param search: boolean - specify whether to use match or search when filtering the
                       returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable([markup('ACCOUNT_NAME'), markup('ACCOUNT_ID')])
        pt.hrules = 1
        pt.align = 'l'
        if account:
            if isinstance(account, IamAccount):
                alist = [account]
            else:
                alist = [self.get_account(account)]
        else:
            alist = self.get_all_accounts(account_name=account_name,
                                          account_id=account_id,
                                          search=search)
        for account in alist:
            pt.add_row([account.name, account.id])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
Exemple #4
0
def SHOW_PROPERTIES_NARROW(connection, properties=None, verbose=True, print_method=None,
                           print_table=True, *prop_names):
    """
    Narrow formatted table used to summarize Eucalyptus properties

    :param connection: EucaAdmin connection
    :param properties: list of EucaProperty objs or string names of properties
    :param verbose: show debug information during table creation
    :param print_table: bool, if True will print table using connection.debug_method()
                        if False will return the table object
    :param prop_names: property names used to filter query response
    """
    if not verbose:
        return connection.show_properties(properties=properties, description=False,
                                          print_method=print_method, print_table=print_table)
    print_method = print_method or connection._show_method
    info_len = 60
    desc_len = 40
    markup_size = len(markup('\n'))
    properties = properties or connection.get_properties(prop_names)
    pt = PrettyTable(['PROPERTY INFO', 'DESCRIPTION'])
    pt.max_width['PROPERTY INFO'] = info_len
    pt.max_width['DESCRIPTION'] = desc_len
    pt.align = 'l'
    pt.padding_width = 0
    pt.hrules = 1
    if not isinstance(properties, list):
        properties = [properties]
    for prop in properties:
        if not isinstance(prop, EucaProperty) and isinstance(prop, basestring):
            props = connection.get_properties(prop)
            if not props:
                continue
        else:
            props = [prop]
        for p in props:
            info_buf = "NAME: "
            prefix = ""
            line_len = info_len - markup_size - len('NAME: ')
            for i in xrange(0, len(p.name), line_len):
                if i:
                    prefix = "      "
                info_buf += (str(prefix + markup(p.name[i:i+line_len], [1, 94]))
                             .ljust(info_len-2) + "\n")
            info_buf += 'VALUE: '
            prefix = ""
            line_len = info_len - markup_size - len('VALUE: ')
            for i in xrange(0, len(p.value), line_len):
                if i:
                    prefix = "       "
                info_buf += (prefix + markup(p.value[i:i+line_len]) + "\n")

            desc_buf = markup('DESCRIPTION:').ljust(desc_len) + str(p.description).ljust(desc_len)
            pt.add_row([info_buf, desc_buf])
    if not pt._rows:
        pt.add_row([markup('NO PROPERTIES RETURNED', [1, 91]), ""])
    if print_table:
        print_method("\n" + str(pt) + "\n")
    else:
        return pt
    def show_all_groups(self, account_name=None,  account_id=None,  path=None, group_name=None,
                        group_id=None,  search=False, print_method=None, print_table=True):
        """
        Print all groups in an account

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for
        :param path: regex - to match for path
        :param group_name: regex - to match for user_name
        :param group_id: regex - to match for user_id
        :param search:  boolean - specify whether to use match or search when filtering
                        the returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable([markup('ACCOUNT:'), markup('GROUPNAME:'), markup('GROUP_ID:')])
        pt.hrules = 1
        pt.align = 'l'
        glist = self.get_all_groups(account_name=account_name, account_id=account_id,
                                    path=path, group_name=group_name, group_id=group_id,
                                    search=search)
        for group in glist:
            pt.add_row([group['account_name'], group['group_name'], group['group_id']])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
def SHOW_PROPERTIES_NARROW(connection, properties=None, verbose=True, print_method=None,
                           print_table=True, *prop_names):
    """
    Narrow formatted table used to summarize Eucalyptus properties

    :param connection: EucaAdmin connection
    :param properties: list of EucaProperty objs or string names of properties
    :param verbose: show debug information during table creation
    :param print_table: bool, if True will print table using connection.debug_method()
                        if False will return the table object
    :param prop_names: property names used to filter query response
    """
    if not verbose:
        return connection.show_properties(properties=properties, description=False,
                                          print_method=print_method, print_table=print_table)
    print_method = print_method or connection._show_method
    info_len = 60
    desc_len = 40
    markup_size = len(markup('\n'))
    properties = properties or connection.get_properties(prop_names)
    pt = PrettyTable(['PROPERTY INFO', 'DESCRIPTION'])
    pt.max_width['PROPERTY INFO'] = info_len
    pt.max_width['DESCRIPTION'] = desc_len
    pt.align = 'l'
    pt.padding_width = 0
    pt.hrules = 1
    if not isinstance(properties, list):
        properties = [properties]
    for prop in properties:
        if not isinstance(prop, EucaProperty) and isinstance(prop, basestring):
            props = connection.get_properties(prop)
            if not props:
                continue
        else:
            props = [prop]
        for p in props:
            info_buf = "NAME: "
            prefix = ""
            line_len = info_len - markup_size - len('NAME: ')
            for i in xrange(0, len(p.name), line_len):
                if i:
                    prefix = "      "
                info_buf += (str(prefix + markup(p.name[i:i+line_len], [1, 94]))
                             .ljust(info_len-2) + "\n")
            info_buf += 'VALUE: '
            prefix = ""
            line_len = info_len - markup_size - len('VALUE: ')
            for i in xrange(0, len(p.value), line_len):
                if i:
                    prefix = "       "
                info_buf += (prefix + markup(p.value[i:i+line_len]) + "\n")

            desc_buf = markup('DESCRIPTION:').ljust(desc_len) + str(p.description).ljust(desc_len)
            pt.add_row([info_buf, desc_buf])
    if not pt._rows:
        pt.add_row([markup('NO PROPERTIES RETURNED', [1, 91]), ""])
    if print_table:
        print_method("\n" + str(pt) + "\n")
    else:
        return pt
def SHOW_CLUSTER_CONTROLLER_SERVICES(connection, ccs=None, print_method=None, print_table=True):
    print_method = print_method or connection._show_method
    hostname_hdr = ('HOSTNAME', 24)
    name_hdr = ('NAME', 24)
    cluster_hdr = ('CLUSTER', 24)
    state_hdr = ('STATE', 16)
    pt = PrettyTable([hostname_hdr[0], name_hdr[0], cluster_hdr[0], state_hdr[0]])
    pt.max_width[hostname_hdr[0]] = hostname_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.max_width[cluster_hdr[0]] = cluster_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.align = 'l'
    pt.padding_width = 0
    if ccs is None:
        ccs = connection.get_all_cluster_controller_services()
    if not isinstance(ccs, list):
        ccs = [ccs]
    for cc in ccs:
        if cc.state == 'ENABLED':
            state = markup(cc.state, [1, 92])
        else:
            state = markup(cc.state, [1, 91])
        pt.add_row([markup(cc.hostname, [1, 94]), cc.name, cc.partition, state])
    if print_table:
        print_method('\n' + pt.get_string(sortby=cluster_hdr[0]) + '\n')
    else:
        return pt
 def get_val_from_host(ip, host, lookup=lookup):
     # Traverse attrs to retrieve the end value...
     if host_attr_chain:
         obj = host
         with hostlock:
             for attr in host_attr_chain:
                 try:
                     obj = getattr(obj, attr)
                 except AttributeError as AE:
                     obj = None
                     errmsg = markup('{0}:{1}'.format(host, str(AE)), [1, 31])
                     debug(errmsg, host, err=True)
             value = obj
     # Use the host method...
     elif host_method_name:
         method = getattr(host, host_method_name, None)
         if method:
             value = method(**host_method_kwargs)
     with hostlock:
         debug(markup('Got value for host: "{0}.{1}" = "{2}"'
                      .format(ip, lookup, value), [1, 94]), host)
         if value_dict.get(value) is not None:
             value_dict[value].append(ip)
         else:
             value_dict[value] = [ip]
Exemple #9
0
 def menu_summary(self, args):
     """Prints Summary of commands and sub-menu items"""
     menu_color = [1, 4, 34] #  bold, underlined, blue
     prevname = None
     names = self.get_names()
     menu_items = []
     maxlen = 0
     main_pt = pt = PrettyTable(['MAIN'])
     main_pt.header = False
     main_pt.border = False
     main_pt.align = 'l'
     sub_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     base_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     current_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     for table in [sub_pt, base_pt, current_pt]:
         table.header = False
         table.border = False
         table.align = 'l'
     #Sort out methods that begin with 'do_' as menu items...
     for name in names:
         if name[:3] == 'do_':
             if name == prevname:
                 continue
             prevname = name
             if len(name[3:]) > maxlen:
                 maxlen = len(name[3:])
             menu_items.append(name)
     #Sort out menu items into: submenus, local commands, and globals
     for name in menu_items:
         cmd = str(name[3:])
         cmd_method = getattr(self, name)
         doc = str(cmd_method.__doc__) or ''
         doc = doc.lstrip().splitlines()[0].strip()
         if hasattr(cmd_method,'__submenu__'):
             if hasattr(BaseMenu, name):
                 base_pt.add_row(["\t{0}".format(markup(cmd, markups=menu_color)),
                                  markup(doc, markups=menu_color)])
             else:
                 current_pt.add_row(["\t{0}".format(markup(cmd, markups=menu_color)),
                                     markup(doc, markups=menu_color)])
         else:
             if hasattr(BaseMenu, name):
                 base_pt.add_row(["\t{0}".format(yellow(cmd, bold=True)), doc])
             else:
                 current_pt.add_row(["\t{0}".format(yellow(cmd, bold=True)), doc])
     buf = "{0}\n".format(cyan('*** ' + self.name.upper() + ' OPTIONS ***', bold=True))
     if current_pt._rows:
         # Add blank line for formatting, separate menu items from commands
         #current_pt.add_row(["\t{0}".format(yellow(" ", bold=True)), ""])
         buf += "{0}\n".format(current_pt.get_string(sortby='COMMAND'))
     if sub_pt._rows:
         buf += "{0}\n".format(sub_pt)
     if base_pt._rows:
         buf += "{0}\n{1}\n".format(cyan('*** BASE COMMANDS ***', bold=True), base_pt)
     main_pt.add_row([buf])
     self.oprint("{0}".format(main_pt))
Exemple #10
0
    def show_all_users(self,
                       users=None,
                       account_name=None,
                       account_id=None,
                       path=None,
                       user_name=None,
                       user_id=None,
                       search=False,
                       print_method=None,
                       print_table=True):
        """
        Debug Method to print a user list based on given filter criteria

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for
        :param path: regex - to match for path
        :param user_name: regex - to match for user_name
        :param user_id: regex - to match for user_id
        :param search: boolean - specify whether to use match or search when filtering the
                                 returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable([
            markup('ACCOUNT:'),
            markup('USERNAME:'******'USER_ID'),
            markup('ACCT_ID')
        ])
        pt.hrules = 1
        pt.align = 'l'
        if users:
            if not isinstance(users, list):
                ulist = [users]
            else:
                ulist = users
            for user in ulist:
                if not isinstance(user, IamUser):
                    raise ValueError(
                        'show_all_users got non IAMUser type: "{0}/{1}"'.
                        format(user, type(user)))
        else:
            ulist = self.get_all_users(account_name=account_name,
                                       account_id=account_id,
                                       path=path,
                                       user_name=user_name,
                                       user_id=user_id,
                                       search=search)
        for user in ulist:
            pt.add_row(
                [user.account_name, user.name, user.id, user.account_id])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
Exemple #11
0
def SHOW_COMPONENTS(connection,
                    components=None,
                    get_method=None,
                    print_method=None,
                    print_table=True):
    """
    Base method for summarizing Eucalyptus components in a table format

    :param connection: EucaAdmin connection
    :param components: EucaServiceComponent objs
    :param get_method: method used to retrieve a list of components to summarize
                      (ie get_all_cluster_controller_services)
    :param print_table: bool, if True will attempt to print the table to connection.debug_method,
                        if False will return the table obj
    """
    print_method = print_method or connection._show_method
    if not components:
        if not get_method:
            raise ValueError(
                '_show_component(). Components or get_method must be populated'
            )
        components = get_method()
    if not isinstance(components, list):
        components = [components]
    hostname_hdr = ('HOSTNAME', 24)
    name_hdr = ('NAME', 50)
    cluster_hdr = ('PARTITION', 24)
    state_hdr = ('STATE', 16)
    type_hdr = ('TYPE', 16)
    pt = PrettyTable([
        hostname_hdr[0], name_hdr[0], cluster_hdr[0], state_hdr[0], type_hdr[0]
    ])
    pt.max_width[hostname_hdr[0]] = hostname_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.max_width[cluster_hdr[0]] = cluster_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.max_width[type_hdr[0]] = type_hdr[1]
    pt.align = 'l'
    pt.padding_width = 0
    for component in components:
        if component.state == 'ENABLED':
            state = markup(component.state, [1, 92])
        else:
            state = markup(component.state, [1, 91])
        pt.add_row([
            markup(component.hostname, [1, 94]), component.name,
            component.partition, state, component.type
        ])
    if print_table:
        print_method('\n' + pt.get_string(sortby=cluster_hdr[0]) + '\n')
    else:
        return pt
Exemple #12
0
 def show_summary(self, printmethod=None, print_table=True):
     printmethod = printmethod or self.connection._show_method
     pt = self.show_machine_mapping(print_table=False)
     if print_table:
         printmethod('\n\t{0}"{1}"\n{2}'.format(markup('\nCLUSTER:'), self.name, str(pt)))
     else:
         return pt
Exemple #13
0
 def get_repo_file_by_baseurl(self, url, repopath=None, cleanurl=True, filters=None):
     """
     Attempts to find a file containing repo info at 'repopath' by matching the provided 'url'
     to the 'baseurl' entries, and return a namespace obj with info
     of the key=value info found.
     :param url: string, baseurl to search repo files for
     :param repopath: dir to search for files
     :param cleanurl: bool, attempts to format an url to a typical baseurl
     :param filters: list of strings.  Will match a subset of the keys found and only return
                     those keys matching a filter.
     :returns namespace with repo info or None upon error, file not found, etc..
     """
     if repopath is None:
         repopath = '/etc/yum.repos.d/*'
     if cleanurl:
         try:
             match = re.match('^(http://\S+/x86_64)', url)
             if match:
                 url = match.group(1)
         except:
             pass
     try:
         out = self.machine.sys('grep "{0}" {1} -l'.format(url, repopath), code=0)
     except CommandExitCodeException as CE:
         self.machine.log.error(markup('Could not find repo for url:"{0}", err:"{1}"'
                                .format(url, str(CE)), markups=[1, 31]))
         return None
     if out:
         filepath = out[0]
         if re.search('^{0}'.format(repopath), filepath):
             return self.get_repo_file(filepath, filters=filters)
     return None
Exemple #14
0
 def status_log(self, msg):
     return self.log.info(
         markup(msg,
                markups=[
                    ForegroundColor.WHITE, BackGroundColor.BG_GREEN,
                    TextStyle.BOLD
                ]))
Exemple #15
0
 def show_packet_test_results(self, results_dict, header=None, printmethod=None, printme=True):
     if not results_dict:
         self.log.warning("Empty results dict passed to show_packet_test_results")
         return
     protocol = results_dict.get("protocol", "???")
     header = header or "PACKET_TEST_RESULTS"
     main_pt = PrettyTable([header])
     main_pt.align = "l"
     main_pt.padding_width = 0
     main_pt.add_row(["{0}".format(results_dict.get("name"))])
     main_pt.add_row(
         ["Elapsed:{0}, Packet Count:{1}".format(results_dict.get("elapsed"), results_dict.get("count"))]
     )
     if results_dict.get("error"):
         main_pt.add_row(["ERROR: {0}".format(markup(results_dict.get("error"), [1, 91]))])
     pt = PrettyTable(["pkt_src_addr", "pkt_dst_addr", "protocol", "port", "pkt_count"])
     for src_addr, s_dict in results_dict.get("packets", {}).iteritems():
         for dst_addr, d_dict in s_dict.iteritems():
             for port, count in d_dict.iteritems():
                 pt.add_row([src_addr, dst_addr, protocol, port, count])
     main_pt.add_row(["{0}".format(pt)])
     if not printme:
         return main_pt
     printmethod = printmethod or self.log.info
     printmethod("\n{0}\n".format(main_pt))
Exemple #16
0
 def get_repo_file(self, filepath, filters=None):
     """
     Read in repo key=value info from a file at 'filepath'.
     :param filepath: string, filepath containing repo info on remote machine
     :param filters: list of strings.  Will match a subset of the keys found and only return
                     those keys matching a filter.
     :returns namespace obj with repo info or None.
     """
     filter_values = filters or []
     values = {'filepath': filepath}
     try:
         out = self.machine.sys('cat {0}'.format(filepath), code=0)
     except CommandExitCodeException as CE:
         self.machine.log.error(
             markup('Failed to read repo_file at:"{0}", err:"{1}"'.format(
                 filepath, str(CE)),
                    markups=[1, 31]))
         return None
     for line in out:
         valname = None
         value = None
         if not line:
             continue
         valmatch = re.search('\s*(\w.*)\s*=\s*(\w.*)\s*$', line)
         if valmatch:
             valname = valmatch.group(1)
             value = valmatch.group(2)
         else:
             namematch = re.search('^\s*\[\s*(\S*)\s*\]\s*$', line)
             if namematch:
                 valname = 'repo_name'
                 value = namematch.group(1)
         if valname and value is not None:
             values[valname] = value
     if not values:
         self.machine.log.error(
             markup('No values parsed from:"{0}"'.format(filepath),
                    markups=[1, 31]))
         return None
     if not filters:
         return RepoFile(**values)
     ret = RepoFile()
     for name in filters:
         if name in values:
             setattr(ret, name, values[name])
     setattr(ret, 'filepath', str(filepath or ""))
     return ret
Exemple #17
0
 def get_repo_file(self, filepath, filters=None):
     """
     Read in repo key=value info from a file at 'filepath'.
     :param filepath: string, filepath containing repo info on remote machine
     :param filters: list of strings.  Will match a subset of the keys found and only return
                     those keys matching a filter.
     :returns namespace obj with repo info or None.
     """
     filter_values = filters or []
     values = {'filepath': filepath}
     try:
         out = self.machine.sys('cat {0}'.format(filepath), code=0)
     except CommandExitCodeException as CE:
         self.machine.log.error(markup('Failed to read repo_file at:"{0}", err:"{1}"'
                                .format(filepath, str(CE)), markups=[1, 31]))
         return None
     for line in out:
         valname = None
         value = None
         if not line:
             continue
         valmatch = re.search('\s*(\w.*)\s*=\s*(\w.*)\s*$', line)
         if valmatch:
             valname = valmatch.group(1)
             value = valmatch.group(2)
         else:
             namematch = re.search('^\s*\[\s*(\S*)\s*\]\s*$', line)
             if namematch:
                 valname = 'repo_name'
                 value = namematch.group(1)
         if valname and value is not None:
             values[valname] = value
     if not values:
         self.machine.log.error(markup('No values parsed from:"{0}"'
                                       .format(filepath), markups=[1, 31]))
         return None
     if not filters:
         return RepoFile(**values)
     ret = RepoFile()
     for name in filters:
         if name in values:
             setattr(ret, name, values[name])
     setattr(ret, 'filepath', str(filepath or ""))
     return ret
Exemple #18
0
def SHOW_COMPONENTS(connection, components=None, get_method=None, print_method=None,
                    print_table=True):
    """
    Base method for summarizing Eucalyptus components in a table format

    :param connection: EucaAdmin connection
    :param components: EucaServiceComponent objs
    :param get_method: method used to retrieve a list of components to summarize
                      (ie get_all_cluster_controller_services)
    :param print_table: bool, if True will attempt to print the table to connection.debug_method,
                        if False will return the table obj
    """
    print_method = print_method or connection._show_method
    if not components:
        if not get_method:
            raise ValueError('_show_component(). Components or get_method must be populated')
        components = get_method()
    if not isinstance(components, list):
        components = [components]
    hostname_hdr = ('HOSTNAME', 24)
    name_hdr = ('NAME', 50)
    cluster_hdr = ('PARTITION', 24)
    state_hdr = ('STATE', 16)
    type_hdr = ('TYPE', 16)
    pt = PrettyTable([hostname_hdr[0], name_hdr[0], cluster_hdr[0], state_hdr[0], type_hdr[0]])
    pt.max_width[hostname_hdr[0]] = hostname_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.max_width[cluster_hdr[0]] = cluster_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.max_width[type_hdr[0]] = type_hdr[1]
    pt.align = 'l'
    pt.padding_width = 0
    for component in components:
        if component.state == 'ENABLED':
            state = markup(component.state, [1, 92])
        else:
            state = markup(component.state, [1, 91])
        pt.add_row([markup(component.hostname, [1, 94]), component.name,
                    component.partition, state, component.type])
    if print_table:
        print_method('\n' + pt.get_string(sortby=cluster_hdr[0]) + '\n')
    else:
        return pt
Exemple #19
0
def show_cluster(connection, cluster, printmethod=None, print_table=True):
    printmethod = printmethod or connection._show_method
    maintpt = PrettyTable([markup('CLUSTER: {0}'.format(cluster.name))])
    machpt = connection.show_machine_mappings(machine_dict=cluster.machines, print_table=False)
    maintpt.add_row([machpt.get_string(sortby=machpt.field_names[1], reversesort=True)])
    proppt = connection.show_properties(cluster.properties, print_table=False)
    maintpt.add_row([proppt.get_string()])
    if print_table:
        printmethod("\n{0}\n".format(maintpt))
    else:
        return maintpt
Exemple #20
0
    def show_all_groups(self,
                        account_name=None,
                        account_id=None,
                        path=None,
                        group_name=None,
                        group_id=None,
                        search=False,
                        print_method=None,
                        print_table=True):
        """
        Print all groups in an account

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for
        :param path: regex - to match for path
        :param group_name: regex - to match for user_name
        :param group_id: regex - to match for user_id
        :param search:  boolean - specify whether to use match or search when filtering
                        the returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable(
            [markup('ACCOUNT:'),
             markup('GROUPNAME:'),
             markup('GROUP_ID:')])
        pt.hrules = 1
        pt.align = 'l'
        glist = self.get_all_groups(account_name=account_name,
                                    account_id=account_id,
                                    path=path,
                                    group_name=group_name,
                                    group_id=group_id,
                                    search=search)
        for group in glist:
            pt.add_row([
                group['account_name'], group['group_name'], group['group_id']
            ])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
Exemple #21
0
 def show_euca_process_summary(self, printmethod=None, print_table=True):
     printmethod = printmethod or self.log.info
     ps_sum = self.get_euca_process_summary()
     serv_hdr = markup('HOST SERVICE', [1, 4])
     pt = PrettyTable([
         serv_hdr,
         markup('COMMAND', [1, 4]),
         markup('%CPU', [1, 4]),
         markup('%MEM', [1, 4]),
         markup('PS_UPTIME', [1, 4])
     ])
     pt.align = 'l'
     pt.align[serv_hdr] = 'r'
     pt.border = 0
     for service, command_dict in ps_sum.iteritems():
         pt.add_row([markup(service + ":", [1, 32]), "", "", "", ""])
         for command, info in command_dict.iteritems():
             pt.add_row([
                 "  --->", command,
                 info.get('%CPU', None),
                 info.get('%MEM', None),
                 info.get('ELAPSED', None)
             ])
     if print_table:
         printmethod("\n{0}\n".format(pt))
     else:
         return pt
Exemple #22
0
 def show_availability_for_node(self, printmethod=None, print_table=True):
     printmethod = printmethod or self.eucahost.log.info
     vmtypes = self.get_vm_availability()
     cap = self.get_last_capacity_status()
     main_pt = PrettyTable(
         [markup('("{0}"\'s VM AVAILABILITY @ {1})').format(self.eucahost.hostname,
                                                            cap.get('timestamp'))])
     main_pt.border = 0
     main_pt.align = 'l'
     cpu_hdr = markup('CPU({0}/{1})'.format(cap.get('cores'), cap.get('cores_total')))
     mem_hdr = markup('MEM({0}/{1})'.format(cap.get('mem'), cap.get('mem_total')))
     disk_hdr = markup('DISK({0}/{1})'.format(cap.get('disk'), cap.get('disk_total')))
     vm_hdr = markup('VMTYPE')
     av_hdr = markup('AVAIL')
     pt = PrettyTable([vm_hdr, av_hdr, cpu_hdr, mem_hdr, disk_hdr])
     pt.align = 'l'
     pt.align[cpu_hdr] = 'c'
     pt.align[av_hdr] = 'c'
     pt.border = 1
     pt.vrules = 2
     pt.hrules = 0
     pt.padding_width = 0
     for t in vmtypes:
         pt.add_row([t.name, "{0} / {1}".format(t.current, t.total), t.cores, t.memory, t.disk])
     main_pt.add_row([pt])
     if print_table:
         printmethod("\n{0}\n".format(main_pt))
     else:
         return main_pt
Exemple #23
0
def SHOW_NODES(connection, nodes=None, print_method=None, print_table=True):
    '''
    Prints table summary of nodes.

    :params nodes:  Can be a single, or list of EucaNodeService objects.
                    Can be a single, or list of node names (strings).
    :param print_table: bool, if true will write table to self.debug_method,
                        if false, will return the table object w/o printing it.
    '''
    print_method = print_method or connection._show_method
    if not nodes:
        nodes_list = connection.get_all_node_controller_services()
    else:
        nodes_list = []
        if not isinstance(nodes, list):
            nodes = [nodes]
        for node in nodes:
            if isinstance(node, EucaNodeService):
                nodes_list.append(node)
            elif isinstance(node, basestring):
                nodes_list.append(connection.get_node_controller_service(name=str(node)))
            else:
                raise ValueError('show_nodes: Unknown type for node: "{0}:{1}"'
                                 .format(node, type(node)))
    ins_id_len = 10
    ins_type_len = 13
    ins_dev_len = 16
    ins_st_len = 15
    zone_hdr = (markup('ZONE'), 20)
    name_hdr = (markup('NODE NAME'), 30)
    state_hdr = (markup('STATE'), 20)
    inst_hdr = (markup('INSTANCES'),
                (ins_id_len + ins_dev_len + ins_type_len + ins_st_len) + 5)

    pt = PrettyTable([zone_hdr[0], name_hdr[0], state_hdr[0], inst_hdr[0]])
    pt.max_width[zone_hdr[0]] = zone_hdr[1]
    pt.max_width[inst_hdr[0]] = inst_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.padding_width = 0
    pt.hrules = 1
    for node in nodes_list:
        instances = "".join("{0}({1}{2}{3})"
                            .format(str(x.id).ljust(ins_id_len),
                                    str(x.state + ",").ljust(ins_st_len),
                                    str(x.instance_type + ",").ljust(ins_type_len),
                                    str(x.root_device_type).ljust(ins_dev_len))
                            .ljust(inst_hdr[1])
                            for x in node.instances)
        instances.strip()
        if node.state == 'ENABLED':
            markups = [1, 92]
        else:
            markups = [1, 91]
        pt.add_row([node.partition, markup(node.name),
                    markup(node.state, markups), instances])
    if print_table:
        print_method('\n' + pt.get_string(sortby=zone_hdr[0]) + '\n')
    else:
        return pt
Exemple #24
0
 def get_url_for_package(self, package_name):
     if package_name in self.repo_url_cache:
         if (time.time() - self.repo_url_cache[package_name]['updated']) <= 10:
             return self.repo_url_cache[package_name]['url']
     out = self.machine.sys('yumdownloader --urls eucalyptus -q', code=0)
     for line in out:
         match = re.match("^(http*.*.rpm)$", line)
         if match:
             line = match.group(1)
             self.repo_url_cache[package_name] = {'updated': time.time(),
                                                  'url': line}
             return line
     self.machine.log.error(markup('URL not found for local package:"{0}"'
                                   .format(package_name), markups=[1, 31]))
    def show_all_users(self, users=None, account_name=None, account_id=None,  path=None,
                       user_name=None, user_id=None, search=False, print_method=None,
                       print_table=True):
        """
        Debug Method to print a user list based on given filter criteria

        :param account_name: regex - to use for account_name
        :param account_id: regex - to use for
        :param path: regex - to match for path
        :param user_name: regex - to match for user_name
        :param user_id: regex - to match for user_id
        :param search: boolean - specify whether to use match or search when filtering the
                                 returned list
        """
        print_method = print_method or self.log.info
        pt = PrettyTable([markup('ACCOUNT:'), markup('USERNAME:'******'USER_ID'),
                          markup('ACCT_ID')])
        pt.hrules = 1
        pt.align = 'l'
        if users:
            if not isinstance(users, list):
                ulist = [users]
            else:
                ulist = users
            for user in ulist:
                if not isinstance(user, IamUser):
                    raise ValueError('show_all_users got non IAMUser type: "{0}/{1}"'
                                     .format(user, type(user)))
        else:
            ulist = self.get_all_users(account_name=account_name, account_id=account_id, path=path,
                                       user_name=user_name, user_id=user_id, search=search)
        for user in ulist:
            pt.add_row([user.account_name, user.name, user.id, user.account_id])
        if print_table:
            print_method("\n" + str(pt) + "\n")
        else:
            return pt
Exemple #26
0
 def test3_download(self):
     """
     Attempts to download the SOS reports from each host in the cloud and store in a local
     directory
     """
     error_msg = ""
     count = 0
     err_count = 0
     host_count = len(self.ip_list)
     for ip in self.ip_list:
         if self.tc:
             if ip in self.tc.sysadmin.eucahosts.keys():
                 host = self.tc.sysadmin.eucahosts.get(ip)
                 ssh = host.ssh
             else:
                 ssh = SshConnection(host=ip, password=self.args.password)
         try:
             remote_tarball_path = ssh.sys(
                 "ls -1 {0}/*.xz | grep {1}".format(self.remote_dir,
                                                    self.ticket_number),
                 code=0)[0]
             tarball_name = os.path.basename(remote_tarball_path)
             local_name = "sosreport-{0}.{1}{2}".format(
                 ip, self.ticket_number,
                 tarball_name.split(str(self.ticket_number))[1])
             local_tarball_path = os.path.join(self.args.local_dir,
                                               local_name)
             self.log.debug("Downloading file to: " + local_tarball_path)
             ssh.sftp_get(localfilepath=local_tarball_path,
                          remotefilepath=remote_tarball_path)
         except Exception, e:
             err_count += 1
             msg = '\nError Downloading from: {0}. Error:"{0}"\n'.format(
                 ip, e)
             self.log.error("{0}\n{1}".format(get_traceback(), msg))
             error_msg += msg
         else:
             count += 1
             self.log.info(
                 markup('Downloaded SOS report {0}/{1} to:{2}'.format(
                     count, host_count, local_tarball_path),
                        markups=[
                            ForegroundColor.WHITE, BackGroundColor.BG_GREEN
                        ]))
Exemple #27
0
 def get_url_for_package(self, package_name):
     if package_name in self.repo_url_cache:
         if (time.time() -
                 self.repo_url_cache[package_name]['updated']) <= 10:
             return self.repo_url_cache[package_name]['url']
     out = self.machine.sys(
         'yumdownloader --urls {0} -q'.format(package_name), code=0)
     for line in out:
         match = re.match("^(http*.*.rpm)$", line)
         if match:
             line = match.group(1)
             self.repo_url_cache[package_name] = {
                 'updated': time.time(),
                 'url': line
             }
             return line
     self.machine.log.error(
         markup(
             'URL not found for local package:"{0}"'.format(package_name),
             markups=[1, 31]))
Exemple #28
0
 def get_repo_file_by_baseurl(self,
                              url,
                              repopath=None,
                              cleanurl=True,
                              filters=None):
     """
     Attempts to find a file containing repo info at 'repopath' by matching the provided 'url'
     to the 'baseurl' entries, and return a namespace obj with info
     of the key=value info found.
     :param url: string, baseurl to search repo files for
     :param repopath: dir to search for files
     :param cleanurl: bool, attempts to format an url to a typical baseurl
     :param filters: list of strings.  Will match a subset of the keys found and only return
                     those keys matching a filter.
     :returns namespace with repo info or None upon error, file not found, etc..
     """
     if repopath is None:
         repopath = '/etc/yum.repos.d/*'
     if cleanurl:
         try:
             match = re.match('^(http://\S+/x86_64)', url)
             if match:
                 url = match.group(1)
         except:
             pass
     try:
         out = self.machine.sys('grep "{0}" {1} -l'.format(url, repopath),
                                code=0)
     except CommandExitCodeException as CE:
         self.machine.log.error(
             markup('Could not find repo for url:"{0}", err:"{1}"'.format(
                 url, str(CE)),
                    markups=[1, 31]))
         return None
     if out:
         filepath = out[0]
         if re.search('^{0}'.format(repopath), filepath):
             return self.get_repo_file(filepath, filters=filters)
     return None
Exemple #29
0
 def clean_all_test_resources(self):
     fault_buf = ""
     for resource_name, resource_list in self.test_resources.iteritems():
         clean_method = self.test_resources_clean_methods.get(resource_name, None)
         if clean_method:
             try:
                 try:
                     clean_method_name = clean_method.__func__.__name__
                 except:
                     clean_method_name = str(clean_method)
                 self.log.debug('Attempting to clean test resources of type:"{0}", '
                                'method:"{1}", artifacts:"{2}"'
                                .format(resource_name, clean_method_name, resource_list))
                 clean_method(resource_list)
             except Exception as E:
                 fault_buf += "{0}\n{1}\n".format(get_traceback(),
                                                  markup('Error while attempting to remove '
                                                         'test resource type:"{0}", '
                                                         'error:"{1}"'
                                                         .format(resource_name, E)))
     if fault_buf:
         raise CleanTestResourcesException(fault_buf)
Exemple #30
0
 def test3_download(self):
     """
     Attempts to download the SOS reports from each host in the cloud and store in a local
     directory
     """
     error_msg = ""
     count = 0
     err_count = 0
     host_count = len(self.ip_list)
     for ip in self.ip_list:
         if self.tc:
             if ip in self.tc.sysadmin.eucahosts.keys():
                 host = self.tc.sysadmin.eucahosts.get(ip)
                 ssh = host.ssh
             else:
                 ssh = SshConnection(host=ip, password=self.args.password)
         try:
             remote_tarball_path = ssh.sys("ls -1 {0}/*.xz | grep {1}"
                                            .format(self.remote_dir, self.ticket_number),
                                            code=0)[0]
             tarball_name = os.path.basename(remote_tarball_path)
             local_name = "sosreport-{0}.{1}{2}".format(ip, self.ticket_number,
                                              tarball_name.split(str(self.ticket_number))[1])
             local_tarball_path = os.path.join(self.args.local_dir, local_name)
             self.log.debug("Downloading file to: " + local_tarball_path)
             ssh.sftp_get(localfilepath=local_tarball_path,
                               remotefilepath=remote_tarball_path)
         except Exception, e:
             err_count += 1
             msg = '\nError Downloading from: {0}. Error:"{0}"\n'.format(ip, e)
             self.log.error("{0}\n{1}".format(get_traceback(), msg))
             error_msg += msg
         else:
             count += 1
             self.log.info(markup('Downloaded SOS report {0}/{1} to:{2}'
                                  .format(count, host_count, local_tarball_path),
                                  markups=[ForegroundColor.WHITE, BackGroundColor.BG_GREEN]))
 def show_packet_test_results(self, results_dict, header=None, printmethod=None, printme=True):
     if not results_dict:
         self.log.warning('Empty results dict passed to show_packet_test_results')
         return
     protocol = results_dict.get('protocol', "???")
     header = header or 'PACKET_TEST_RESULTS'
     main_pt = PrettyTable([header])
     main_pt.align = 'l'
     main_pt.padding_width = 0
     main_pt.add_row(["{0}".format(results_dict.get('name'))])
     main_pt.add_row(["Elapsed:{0}, Packet Count:{1}".format(results_dict.get('elapsed'),
                                                     results_dict.get('count'))])
     if results_dict.get('error'):
         main_pt.add_row(["ERROR: {0}".format(markup(results_dict.get('error'), [1, 91]))])
     pt = PrettyTable(['pkt_src_addr', 'pkt_dst_addr', 'protocol', 'port', 'pkt_count'])
     for src_addr, s_dict in results_dict.get('packets', {}).iteritems():
         for dst_addr, d_dict in s_dict.iteritems():
             for port, count in d_dict.iteritems():
                 pt.add_row([src_addr, dst_addr, protocol, port, count])
     main_pt.add_row(["{0}".format(pt)])
     if not printme:
         return main_pt
     printmethod = printmethod or self.log.info
     printmethod("\n{0}\n".format(main_pt))
Exemple #32
0
 def clean_all_test_resources(self):
     fault_buf = ""
     for resource_name, resource_list in self.test_resources.iteritems():
         clean_method = self.test_resources_clean_methods.get(
             resource_name, None)
         if clean_method:
             try:
                 try:
                     clean_method_name = clean_method.__func__.__name__
                 except:
                     clean_method_name = str(clean_method)
                 self.log.debug(
                     'Attempting to clean test resources of type:"{0}", '
                     'method:"{1}", artifacts:"{2}"'.format(
                         resource_name, clean_method_name, resource_list))
                 clean_method(resource_list)
             except Exception as E:
                 fault_buf += "{0}\n{1}\n".format(
                     get_traceback(),
                     markup('Error while attempting to remove '
                            'test resource type:"{0}", '
                            'error:"{1}"'.format(resource_name, E)))
     if fault_buf:
         raise CleanTestResourcesException(fault_buf)
Exemple #33
0
 def show_euca_process_summary(self, printmethod=None, print_table=True):
     printmethod = printmethod or self.log.info
     ps_sum = self.get_euca_process_summary()
     serv_hdr = markup('HOST SERVICE', [1, 4])
     pt = PrettyTable([serv_hdr,
                       markup('COMMAND', [1, 4]),
                       markup('%CPU', [1, 4]),
                       markup('%MEM', [1, 4]),
                       markup('PS_UPTIME', [1, 4])])
     pt.align = 'l'
     pt.align[serv_hdr] = 'r'
     pt.border = 0
     for service, command_dict in ps_sum.iteritems():
         pt.add_row([markup(service + ":", [1, 32]), "", "", "", ""])
         for command, info in command_dict.iteritems():
             pt.add_row(["  --->", command, info.get('%CPU', None),
                         info.get('%MEM', None), info.get('ELAPSED', None)])
     if print_table:
         printmethod("\n{0}\n".format(pt))
     else:
         return pt
Exemple #34
0
 def show_availability_for_node(self, printmethod=None, print_table=True):
     printmethod = printmethod or self.eucahost.log.info
     vmtypes = self.get_vm_availability()
     cap = self.get_last_capacity_status()
     main_pt = PrettyTable([
         markup('("{0}"\'s VM AVAILABILITY @ {1})').format(
             self.eucahost.hostname, cap.get('timestamp'))
     ])
     main_pt.border = 0
     main_pt.align = 'l'
     cpu_hdr = markup('CPU({0}/{1})'.format(cap.get('cores'),
                                            cap.get('cores_total')))
     mem_hdr = markup('MEM({0}/{1})'.format(cap.get('mem'),
                                            cap.get('mem_total')))
     disk_hdr = markup('DISK({0}/{1})'.format(cap.get('disk'),
                                              cap.get('disk_total')))
     vm_hdr = markup('VMTYPE')
     av_hdr = markup('AVAIL')
     pt = PrettyTable([vm_hdr, av_hdr, cpu_hdr, mem_hdr, disk_hdr])
     pt.align = 'l'
     pt.align[cpu_hdr] = 'c'
     pt.align[av_hdr] = 'c'
     pt.border = 1
     pt.vrules = 2
     pt.hrules = 0
     pt.padding_width = 0
     for t in vmtypes:
         pt.add_row([
             t.name, "{0} / {1}".format(t.current, t.total), t.cores,
             t.memory, t.disk
         ])
     main_pt.add_row([pt])
     if print_table:
         printmethod("\n{0}\n".format(main_pt))
     else:
         return main_pt
Exemple #35
0
def run_instance_with_user(user):
    my_error = {}
    err_string = ""
    instance_str = ""
    setattr(user, "results", {})
    instances = []
    vpc_ids = []
    subnet_ids = []
    my_md_times = {}
    my_clc_times = None
    try:
        emi = user.ec2.get_emi(
            root_device_type="instance-store", filters={"virtualization-type": "hvm"}, basic_image=True
        )
        key = user.ec2.create_keypair_and_localcert(
            "key_{0}_{1}_{2}".format(user.account_name, user.user_name, int(time.time()))
        )
        if not key:
            raise RuntimeError(
                "Could not find or create key for account/user:{0}/{1}".format(user.account_name, user.user_name)
            )
        group = user.ec2.add_group("group_{0}_{1}".format(user.account_name, user.user_name))
        user.ec2.authorize_group(group=group, port=22, protocol="tcp")
        user.ec2.authorize_group(group=group, port=-1, protocol="icmp")
        start = time.time()
        for zone, count in zones.iteritems():
            instances += user.ec2.run_image(
                image=emi,
                keypair=key,
                group=group,
                min=count,
                max=count,
                zone=zone,
                timeout=instance_timeout,
                monitor_to_running=False,
                clean_on_fail=False,
                auto_connect=True,
            )
        for i in instances:
            if not i.vpc_id in vpc_ids:
                vpc_ids.append(i.vpc_id)
            if not i.subnet_id in subnet_ids:
                subnet_ids.append(i.subnet_id)
        elapsed = int(time.time() - start)
        my_clc_times = get_clc_artifacts_for_vpc(user, vpc_ids, subnet_ids, addtime=elapsed)
        elapsed = int(time.time() - start)
        my_md_times = wait_for_mido_metadata_nat_rule(instances, addtime=elapsed)
        user.ec2.monitor_euinstances_to_running(instances, timeout=instance_timeout)
        instance_str = "\n".join("{0}:{1}".format(x.id, x.placement) for x in instances)
        my_results = {"user": str(user), "result": "PASSED", "instances": instance_str}
    except Exception as E:
        user.log.debug("{0}\nError:{1}".format(get_traceback(), E))
        err_string += "{0}\nError:{1}".format(get_traceback(), E)
        my_results = {"user": str(user), "result": markup("FAILED", [1, 91]), "instances": instance_str}
        try:
            for vpc_id in vpc_ids:
                cmd = "ps aux  | grep {0}".format(vpc_id)
                err_string += "\nCLC CMD#: {0}\n".format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
            tc.log.error("Failed to get vpc process info from clc:" + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        try:
            for vpc_id in vpc_ids:
                cmd = "ifconfig | grep {0}".format(str(vpc_id).lstrip("vpc-"))
                err_string += "\nCLC CMD#: {0}\n".format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
            tc.log.error("Failed to get vpc ifconfig info from clc:" + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        try:
            for subnet_id in subnet_ids:
                cmd = "ifconfig | grep {0}".format(str(subnet_id).lstrip("subnet-"))
                err_string += "\nCLC CMD#: {0}\n".format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
            tc.log.error("Failed to get subnet ifconfig info from clc:" + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        for i in instances:
            try:
                cmd = "grep {0} /var/run/eucalyptus/eucanetd_vpc_instance_ip_map".format(i.id)
                err_string += "\nCLC CMD#: {0}\n".format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
            except Exception as E:
                tc.log.error("Failed to get vpc nginx map info from clc:" + str(E))
            finally:
                err_string += "(CMD DONE)\n"
            err_string += i.get_cloud_init_info_from_console() + "\n"

    finally:
        try:
            for ins in instances:
                if ins and ins.ssh:
                    ins.ssh.close()
                ins = None
            instances = None
        except Exception as E:
            err_string += "{0}\nError:{1}".format(get_traceback(), E)
            user.log.warn("")
        user.results = my_results
        with userlock:
            if err_string:
                my_error = {"user": str(user), "error": err_string}
                errors.append(my_error)
            if my_clc_times:
                for key, value in my_clc_times.iteritems():
                    clc_times[key] = value
            if my_md_times:
                for key, value in my_md_times.iteritems():
                    mido_md_times[key] = value
Exemple #36
0
def run_instance_with_user(user):
    my_error = {}
    err_string = ""
    instance_str = ""
    setattr(user, 'results', {})
    instances = []
    vpc_ids = []
    subnet_ids = []
    my_md_times = {}
    my_clc_times = None
    try:
        emi = user.ec2.get_emi(root_device_type='instance-store',
                               filters={'virtualization-type': 'hvm'},
                               basic_image=True)
        key = user.ec2.create_keypair_and_localcert('key_{0}_{1}_{2}'
                                                    .format(user.account_name, user.user_name,
                                                            int(time.time())))
        if not key:
            raise RuntimeError('Could not find or create key for account/user:{0}/{1}'
                               .format(user.account_name, user.user_name))
        group = user.ec2.add_group('group_{0}_{1}'.format(user.account_name, user.user_name))
        user.ec2.authorize_group(group=group, port=22, protocol='tcp')
        user.ec2.authorize_group(group=group, port=-1, protocol='icmp')
        start = time.time()
        for zone, count in zones.iteritems():
            instances += user.ec2.run_image(image=emi, keypair = key, group=group, min=count,
                                            max=count, zone=zone, timeout=instance_timeout,
                                            monitor_to_running=False, clean_on_fail=False,
                                            auto_connect=True)
        for i in instances:
            if not i.vpc_id in vpc_ids:
                vpc_ids.append(i.vpc_id)
            if not i.subnet_id in subnet_ids:
                subnet_ids.append(i.subnet_id)
        elapsed = int(time.time() - start)
        my_clc_times = get_clc_artifacts_for_vpc(user, vpc_ids, subnet_ids, addtime=elapsed)
        elapsed = int(time.time() - start)
        my_md_times = wait_for_mido_metadata_nat_rule(instances, addtime=elapsed)
        user.ec2.monitor_euinstances_to_running(instances, timeout=instance_timeout)
        instance_str = "\n".join("{0}:{1}".format(x.id, x.placement) for x in instances)
        my_results = {'user':str(user), 'result':'PASSED', 'instances':instance_str}
    except Exception as E:
        user.log.debug('{0}\nError:{1}'.format(get_traceback(), E))
        err_string += '{0}\nError:{1}'.format(get_traceback(), E)
        my_results = {'user':str(user), 'result': markup('FAILED', [1, 91]),
                      'instances':instance_str}
        try:
            for vpc_id in vpc_ids:
                cmd = 'ps aux  | grep {0}'.format(vpc_id)
                err_string += '\nCLC CMD#: {0}\n'.format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
             tc.log.error('Failed to get vpc process info from clc:' + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        try:
            for vpc_id in vpc_ids:
                cmd = 'ifconfig | grep {0}'.format(str(vpc_id).lstrip('vpc-'))
                err_string += '\nCLC CMD#: {0}\n'.format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
             tc.log.error('Failed to get vpc ifconfig info from clc:' + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        try:
            for subnet_id in subnet_ids:
                cmd = 'ifconfig | grep {0}'.format(str(subnet_id).lstrip('subnet-'))
                err_string += '\nCLC CMD#: {0}\n'.format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
        except Exception as E:
             tc.log.error('Failed to get subnet ifconfig info from clc:' + str(E))
        finally:
            err_string += "(CMD DONE)\n"
        for i in instances:
            try:
                cmd = "grep {0} /var/run/eucalyptus/eucanetd_vpc_instance_ip_map".format(i.id)
                err_string += '\nCLC CMD#: {0}\n'.format(cmd)
                err_string += tc.sysadmin.clc_machine.sys(cmd, listformat=False)
            except Exception as E:
                tc.log.error('Failed to get vpc nginx map info from clc:' + str(E))
            finally:
                err_string += "(CMD DONE)\n"
            err_string += i.get_cloud_init_info_from_console() + "\n"

    finally:
        try:
            for ins in instances:
                if ins and ins.ssh:
                    ins.ssh.close()
                ins = None
            instances = None
        except Exception as E:
            err_string += '{0}\nError:{1}'.format(get_traceback(), E)
            user.log.warn('')
        user.results = my_results
        with userlock:
            if err_string:
                my_error = {'user':str(user), 'error':err_string}
                errors.append(my_error)
            if my_clc_times:
                for key, value in my_clc_times.iteritems():
                    clc_times[key] = value
            if my_md_times:
                for key, value in my_md_times.iteritems():
                    mido_md_times[key] = value
def SHOW_NODES(connection, nodes=None, print_method=None, print_table=True):
    '''
    Prints table summary of nodes.

    :params nodes:  Can be a single, or list of EucaNodeService objects.
                    Can be a single, or list of node names (strings).
    :param print_table: bool, if true will write table to self.debug_method,
                        if false, will return the table object w/o printing it.
    '''
    print_method = print_method or connection._show_method
    if not nodes:
        nodes_list = connection.get_all_node_controller_services()
    else:
        nodes_list = []
        if not isinstance(nodes, list):
            nodes = [nodes]
        for node in nodes:
            if isinstance(node, EucaNodeService):
                nodes_list.append(node)
            elif isinstance(node, basestring):
                nodes_list.append(
                    connection.get_node_controller_service(name=str(node)))
            else:
                raise ValueError(
                    'show_nodes: Unknown type for node: "{0}:{1}"'.format(
                        node, type(node)))
    ins_id_len = 10
    ins_type_len = 13
    ins_dev_len = 16
    ins_st_len = 15
    zone_hdr = (markup('ZONE'), 20)
    name_hdr = (markup('NODE NAME'), 30)
    state_hdr = (markup('STATE'), 20)
    inst_hdr = (markup('INSTANCES'),
                (ins_id_len + ins_dev_len + ins_type_len + ins_st_len) + 5)

    pt = PrettyTable([zone_hdr[0], name_hdr[0], state_hdr[0], inst_hdr[0]])
    pt.max_width[zone_hdr[0]] = zone_hdr[1]
    pt.max_width[inst_hdr[0]] = inst_hdr[1]
    pt.max_width[state_hdr[0]] = state_hdr[1]
    pt.max_width[name_hdr[0]] = name_hdr[1]
    pt.padding_width = 0
    pt.hrules = 1
    for node in nodes_list:
        instances = "".join("{0}({1}{2}{3})".format(
            str(x.id).ljust(ins_id_len),
            str(x.state + ",").ljust(ins_st_len),
            str(x.instance_type + ",").ljust(ins_type_len),
            str(x.root_device_type).ljust(ins_dev_len)).ljust(inst_hdr[1])
                            for x in node.instances)
        instances.strip()
        if node.state == 'ENABLED':
            markups = [1, 92]
        else:
            markups = [1, 91]
        pt.add_row([
            node.partition,
            markup(node.name),
            markup(node.state, markups), instances
        ])
    if print_table:
        print_method('\n' + pt.get_string(sortby=zone_hdr[0]) + '\n')
    else:
        return pt
Exemple #38
0
 def n_markup(*args, **kwargs):
     kwargs['do_html'] = do_html
     kwargs['html_open'] = html_open
     kwargs['html_close'] = html_close
     return markup(*args, **kwargs)
Exemple #39
0
 def add_host(hostip, host, self=self):
     assert isinstance(host, EucaHost)
     servbuf = header + "\n"
     mservices = []
     # Get the child services (ie for UFS)
     for serv in host.services:
         mservices.append(serv)
         mservices.extend(serv.child_services)
     for serv in mservices:
         for line in serv_lines:
             # Remove the ansi markup for parsing purposes, but leave it in the
             # displayed line
             clean_line = ansi_escape.sub('', line)
             splitline = clean_line.split()
             if len(splitline) < 2:
                 continue
             line_type = splitline[0]
             line_name = splitline[1]
             # Pull matching lines out of the pre-formatted service table...
             if (splitline
                     and re.match("^{0}$".format(serv.type), line_type)
                     and re.match("^{0}$".format(serv.name),
                                  line_name)):
                 # Add this line to the services to be displayed for this machine
                 if line_name not in servbuf:
                     servbuf += line + "\n"
         if serv.type == 'node':
             if getattr(serv, 'instances', None):
                 if serv.instances:
                     vm_pt = PrettyTable([
                         markup('INSTANCES', [1, 4]),
                         markup('STATE:', [1, 4]),
                         markup('VMTYPE:', [1, 4]),
                         markup('ROOT_DEV:', [1, 4])
                     ])
                     vm_pt.align = 'l'
                     vm_pt.border = 1
                     vm_pt.vrules = 2
                     vm_pt.hrules = 0
                     for x in serv.instances:
                         vm_pt.add_row([
                             x.id,
                             markup(x.state,
                                    self.vm_state_markup(x.state)),
                             x.instance_type, x.root_device_type
                         ])
                     servbuf += "{0}\n".format(vm_pt)
             av_pt = host.helpers.node_controller.show_availability_for_node(
                 print_table=False)
             servbuf += av_pt.get_string()
     ps_sum_pt = host.show_euca_process_summary(print_table=False)
     servbuf += "\n" + ps_sum_pt.get_string(
         border=1, vrules=2, hrules=0)
     host_info = markup('Euca Versions:').ljust(machine_hdr[1])
     host_info += "Cloud: {0}".format(
         host.get_eucalyptus_version()).ljust(machine_hdr[1])
     host_info += "2ools: {0}".format(
         host.get_euca2ools_version()).ljust(machine_hdr[1])
     host_info += markup("Hostname:").ljust(machine_hdr[1])
     host_info += str(host.hostname).ljust(machine_hdr[1])
     sys_pt = host.show_sys_info(print_table=False)
     host_info += "{0}".format(sys_pt)
     with hostlock:
         pt.add_row([
             markup("HOST:") + markup(hostip, [1, 94]),
             markup('EUCALYPTUS SERVICES:') + markup(
                 '[ {0} ]'.format(" ".join(
                     str(x) for x in host.euca_service_codes)), [1, 34])
         ])
         pt.add_row([host_info, servbuf])
Exemple #40
0
    def show_hosts(self,
                   hosts=None,
                   partition=None,
                   service_type=None,
                   serv_columns=None,
                   update=True,
                   print_method=None,
                   print_table=True,
                   save_file=None):
        print_method = print_method or self._show_method
        ins_id_len = 10
        ins_type_len = 13
        ins_dev_len = 16
        ins_st_len = 15
        ins_total = (ins_id_len + ins_dev_len + ins_type_len + ins_st_len) + 5
        machine_hdr = (markup('MACHINE INFO'), 30)
        service_hdr = (markup('EUCALYPTUS SERVICES'), 90)
        pt = PrettyTable([machine_hdr[0], service_hdr[0]])
        pt.header = False
        pt.align = 'l'
        pt.hrules = 1
        pt.max_width[machine_hdr[0]] = machine_hdr[1]
        total = []
        eucahosts = {}
        if hosts is None:
            eucahosts = self.eucahosts
        elif isinstance(hosts, list):
            for host in hosts:
                eucahosts[host.hostname] = host
        elif isinstance(hosts, EucaHost):
            eucahosts[hosts.hostname] = hosts

        if not isinstance(eucahosts, dict):
            raise ValueError('show_machine_mappings requires dict example: '
                             '{"host ip":[host objs]}, got:"{0}/{1}"'.format(
                                 eucahosts, type(eucahosts)))
        # To format the tables services, print them all at once and then sort the table
        # rows string into the machines columns
        try:
            sorted_ips = sorted(
                list(eucahosts),
                key=lambda ip: struct.unpack("!L", socket.inet_aton(ip))[0])
        except Exception as SE:
            self.log.warning(
                '"Failed to sort host list by IP, error:"{0}"'.format(SE))
            sorted_ips = sorted(list(eucahosts))
        for hostip in sorted_ips:
            host = eucahosts[hostip]
            for serv in host.services:
                if update:
                    serv.update()
                total.append(serv)
                if serv.child_services:
                    total.extend(serv.child_services)
        # Create a table showing the service states, grab the first 3 columns
        # for type, name, state, and zone
        servpt = self.show_services(total, print_table=False)
        # Get a subset of the show services fields...
        if serv_columns is None:
            fields = servpt._field_names[0:4]
        else:
            fields = servpt._fields_names[serv_columns]
        serv_lines = servpt.get_string(border=0,
                                       padding_width=2,
                                       fields=fields).splitlines()
        header = serv_lines[0]
        ansi_escape = re.compile(r'\x1b[^m]*m')
        # Now build the machine table...
        threads = []
        hostlock = threading.Lock()

        # Method to allow host info to be gathered concurrently
        def add_host(hostip, host, self=self):
            assert isinstance(host, EucaHost)
            servbuf = header + "\n"
            mservices = []
            # Get the child services (ie for UFS)
            for serv in host.services:
                mservices.append(serv)
                mservices.extend(serv.child_services)
            for serv in mservices:
                for line in serv_lines:
                    # Remove the ansi markup for parsing purposes, but leave it in the
                    # displayed line
                    clean_line = ansi_escape.sub('', line)
                    splitline = clean_line.split()
                    if len(splitline) < 2:
                        continue
                    line_type = splitline[0]
                    line_name = splitline[1]
                    # Pull matching lines out of the pre-formatted service table...
                    if (splitline
                            and re.match("^{0}$".format(serv.type), line_type)
                            and re.match("^{0}$".format(serv.name),
                                         line_name)):
                        # Add this line to the services to be displayed for this machine
                        if line_name not in servbuf:
                            servbuf += line + "\n"
                if serv.type == 'node':
                    if getattr(serv, 'instances', None):
                        if serv.instances:
                            vm_pt = PrettyTable([
                                markup('INSTANCES', [1, 4]),
                                markup('STATE:', [1, 4]),
                                markup('VMTYPE:', [1, 4]),
                                markup('ROOT_DEV:', [1, 4])
                            ])
                            vm_pt.align = 'l'
                            vm_pt.border = 1
                            vm_pt.vrules = 2
                            vm_pt.hrules = 0
                            for x in serv.instances:
                                vm_pt.add_row([
                                    x.id,
                                    markup(x.state,
                                           self.vm_state_markup(x.state)),
                                    x.instance_type, x.root_device_type
                                ])
                            servbuf += "{0}\n".format(vm_pt)
                    av_pt = host.helpers.node_controller.show_availability_for_node(
                        print_table=False)
                    servbuf += av_pt.get_string()
            ps_sum_pt = host.show_euca_process_summary(print_table=False)
            servbuf += "\n" + ps_sum_pt.get_string(
                border=1, vrules=2, hrules=0)
            host_info = markup('Euca Versions:').ljust(machine_hdr[1])
            host_info += "Cloud: {0}".format(
                host.get_eucalyptus_version()).ljust(machine_hdr[1])
            host_info += "2ools: {0}".format(
                host.get_euca2ools_version()).ljust(machine_hdr[1])
            host_info += markup("Hostname:").ljust(machine_hdr[1])
            host_info += str(host.hostname).ljust(machine_hdr[1])
            sys_pt = host.show_sys_info(print_table=False)
            host_info += "{0}".format(sys_pt)
            with hostlock:
                pt.add_row([
                    markup("HOST:") + markup(hostip, [1, 94]),
                    markup('EUCALYPTUS SERVICES:') + markup(
                        '[ {0} ]'.format(" ".join(
                            str(x) for x in host.euca_service_codes)), [1, 34])
                ])
                pt.add_row([host_info, servbuf])

        for hostip, host in eucahosts.iteritems():
            t = threading.Thread(target=add_host, args=(hostip, host))
            t.start()
            threads.append(t)
        for t in threads:
            t.join()
        if save_file:
            with open(save_file, 'w') as sf:
                sf.write("\n{0}\n".format(pt.get_string()))
        if print_table:
            # print_method("\n{0}\n".format(pt.get_string(sortby=pt.field_names[1])))
            print_method("\n{0}\n".format(pt.get_string()))
        else:
            return pt
Exemple #41
0
def SHOW_PROPERTIES(connection, properties=None, description=True, defaults=True, readonly=True,
                    grid=ALL, print_method=None, print_table=True, search=None, *nameprefix):
    """
    Summarize Eucalyptus properties in table format

    :param connection: EucaAdmin connection
    :param properties: list of property names, or Eucaproperties to summarize
    :param description: bool, show property descriptions
    :param grid: bool, show table in grid format
    :param readonly: bool, show readonly flag
    :param defaults: bool, show property defaults in table
    :param print_table: bool, if True will print table using connection.debug_method()
                        if False will return the table object
    :param search: string, to use as filter for name of properties
    :param nameprefix: property names used to filter query response
    """
    print_method = print_method or connection._show_method
    name_hdr = markup('PROPERTY NAME', [1, 94])
    def_hdr = markup('DEFAULT', [1, 94])
    value_hdr = markup('PROPERTY VALUE', [1, 94])
    desc_hdr = markup('DESCRIPTION', [1, 94])
    ro_hdr = markup('RO', [1, 94])
    pt = PrettyTable([name_hdr, value_hdr])
    pt.max_width[name_hdr] = 70
    pt.max_width[value_hdr] = 40

    if defaults:
        pt.add_column(fieldname=def_hdr, column=[])
        pt.max_width[def_hdr] = 40
    if readonly:
        pt.add_column(fieldname=ro_hdr, column=[])
    if description:
        pt.add_column(fieldname=desc_hdr, column=[])
        pt.max_width[desc_hdr] = 40
        # Reduce the default width to accommodate the description
        pt.max_width[def_hdr] = 20

    pt.padding_width = 0
    pt.align = 'l'
    pt.hrules = grid or 0
    if not isinstance(properties, list):
        properties = properties or connection.get_properties(search=search, *nameprefix)
    if not isinstance(properties, list):
        properties = [properties]
    for prop in properties:
        if not isinstance(prop, EucaProperty) and isinstance(prop, basestring):
            props = connection.get_properties(prop)
            if not props:
                continue
        else:
            props = [prop]
        for p in props:
            row = [markup(p.name, [94]), p.value]
            if defaults:
                row.append(getattr(p, 'defaultvalue', None))
            if readonly:
                ro = getattr(p, 'readonly', "?")
                if ro != "?":
                    if 'rue' in ro:
                        ro = 'T'
                    if 'alse' in ro:
                        ro = 'F'
                row.append(ro)
            if description:
                row.append(p.description)
            pt.add_row(row)
    if not pt._rows:
        err_row = [markup('NO PROPERTIES RETURNED', [1, 91])]
        for x in xrange(1, len(pt._field_names)):
            err_row.append("")
        pt.add_row(err_row)
    if print_table:
        print_method('\n' + str(pt) + '\n')
    else:
        return pt
Exemple #42
0
 def n_markup(*args, **kwargs):
     kwargs['do_html'] = do_html
     kwargs['html_open'] = html_open
     kwargs['html_close'] = html_close
     return markup(*args, **kwargs)
Exemple #43
0
 def n_markup(*args, **kwargs):
     kwargs["do_html"] = do_html
     kwargs["html_open"] = html_open
     kwargs["html_close"] = html_close
     return markup(*args, **kwargs)
def SHOW_PROPERTIES(connection, properties=None, description=True, defaults=True, readonly=True,
                    grid=ALL, print_method=None, print_table=True, search=None, *nameprefix):
    """
    Summarize Eucalyptus properties in table format

    :param connection: EucaAdmin connection
    :param properties: list of property names, or Eucaproperties to summarize
    :param description: bool, show property descriptions
    :param grid: bool, show table in grid format
    :param readonly: bool, show readonly flag
    :param defaults: bool, show property defaults in table
    :param print_table: bool, if True will print table using connection.debug_method()
                        if False will return the table object
    :param search: string, to use as filter for name of properties
    :param nameprefix: property names used to filter query response
    """
    print_method = print_method or connection._show_method
    name_hdr = markup('PROPERTY NAME', [1, 94])
    def_hdr = markup('DEFAULT', [1, 94])
    value_hdr = markup('PROPERTY VALUE', [1, 94])
    desc_hdr = markup('DESCRIPTION', [1, 94])
    ro_hdr = markup('RO', [1, 94])
    pt = PrettyTable([name_hdr, value_hdr])
    pt.max_width[name_hdr] = 70
    pt.max_width[value_hdr] = 40

    if defaults:
        pt.add_column(fieldname=def_hdr, column=[])
        pt.max_width[def_hdr] = 40
    if readonly:
        pt.add_column(fieldname=ro_hdr, column=[])
    if description:
        pt.add_column(fieldname=desc_hdr, column=[])
        pt.max_width[desc_hdr] = 40
        # Reduce the default width to accommodate the description
        pt.max_width[def_hdr] = 20

    pt.padding_width = 0
    pt.align = 'l'
    pt.hrules = grid or 0
    if not isinstance(properties, list):
        properties = properties or connection.get_properties(search=search, *nameprefix)
    if not isinstance(properties, list):
        properties = [properties]
    for prop in properties:
        if not isinstance(prop, EucaProperty) and isinstance(prop, basestring):
            props = connection.get_properties(prop)
            if not props:
                continue
        else:
            props = [prop]
        for p in props:
            row = [markup(p.name, [94]), p.value]
            if defaults:
                row.append(getattr(p, 'defaultvalue', None))
            if readonly:
                ro = getattr(p, 'readonly', "?")
                if ro != "?":
                    if 'rue' in ro:
                        ro = 'T'
                    if 'alse' in ro:
                        ro = 'F'
                row.append(ro)
            if description:
                row.append(p.description)
            pt.add_row(row)
    if not pt._rows:
        err_row = [markup('NO PROPERTIES RETURNED', [1, 91])]
        for x in xrange(1, len(pt._field_names)):
            err_row.append("")
        pt.add_row(err_row)
    if print_table:
        print_method('\n' + str(pt) + '\n')
    else:
        return pt
Exemple #45
0
 def add_host(hostip, host, self=self):
     assert isinstance(host, EucaHost)
     servbuf = header + "\n"
     mservices = []
     # Get the child services (ie for UFS)
     for serv in host.services:
         mservices.append(serv)
         mservices.extend(serv.child_services)
     for serv in mservices:
         for line in serv_lines:
             # Remove the ansi markup for parsing purposes, but leave it in the
             # displayed line
             clean_line = ansi_escape.sub("", line)
             splitline = clean_line.split()
             if len(splitline) < 2:
                 continue
             line_type = splitline[0]
             line_name = splitline[1]
             # Pull matching lines out of the pre-formatted service table...
             if (
                 splitline
                 and re.match("^{0}$".format(serv.type), line_type)
                 and re.match("^{0}$".format(serv.name), line_name)
             ):
                 # Add this line to the services to be displayed for this machine
                 if line_name not in servbuf:
                     servbuf += line + "\n"
         if serv.type == "node":
             if getattr(serv, "instances", None):
                 if serv.instances:
                     vm_pt = PrettyTable(
                         [
                             markup("INSTANCES", [1, 4]),
                             markup("STATE:", [1, 4]),
                             markup("VMTYPE:", [1, 4]),
                             markup("ROOT_DEV:", [1, 4]),
                         ]
                     )
                     vm_pt.align = "l"
                     vm_pt.border = 1
                     vm_pt.vrules = 2
                     vm_pt.hrules = 0
                     for x in serv.instances:
                         vm_pt.add_row(
                             [
                                 x.id,
                                 markup(x.state, self.vm_state_markup(x.state)),
                                 x.instance_type,
                                 x.root_device_type,
                             ]
                         )
                     servbuf += "{0}\n".format(vm_pt)
             av_pt = host.helpers.node_controller.show_availability_for_node(print_table=False)
             servbuf += av_pt.get_string()
     ps_sum_pt = host.show_euca_process_summary(print_table=False)
     servbuf += "\n" + ps_sum_pt.get_string(border=1, vrules=2, hrules=0)
     host_info = markup("Euca Versions:").ljust(machine_hdr[1])
     host_info += "Cloud: {0}".format(host.get_eucalyptus_version()).ljust(machine_hdr[1])
     host_info += "2ools: {0}".format(host.get_euca2ools_version()).ljust(machine_hdr[1])
     host_info += markup("Hostname:").ljust(machine_hdr[1])
     host_info += str(host.hostname).ljust(machine_hdr[1])
     sys_pt = host.show_sys_info(print_table=False)
     host_info += "{0}".format(sys_pt)
     with hostlock:
         pt.add_row(
             [
                 markup("HOST:") + markup(hostip, [1, 94]),
                 markup("EUCALYPTUS SERVICES:")
                 + markup("[ {0} ]".format(" ".join(str(x) for x in host.euca_service_codes)), [1, 34]),
             ]
         )
         pt.add_row([host_info, servbuf])
Exemple #46
0
    def show_hosts(
        self,
        hosts=None,
        partition=None,
        service_type=None,
        serv_columns=None,
        update=True,
        print_method=None,
        print_table=True,
        save_file=None,
    ):
        print_method = print_method or self._show_method
        ins_id_len = 10
        ins_type_len = 13
        ins_dev_len = 16
        ins_st_len = 15
        ins_total = (ins_id_len + ins_dev_len + ins_type_len + ins_st_len) + 5
        machine_hdr = (markup("MACHINE INFO"), 30)
        service_hdr = (markup("EUCALYPTUS SERVICES"), 90)
        pt = PrettyTable([machine_hdr[0], service_hdr[0]])
        pt.header = False
        pt.align = "l"
        pt.hrules = 1
        pt.max_width[machine_hdr[0]] = machine_hdr[1]
        total = []
        eucahosts = {}
        if hosts is None:
            eucahosts = self.eucahosts
        elif isinstance(hosts, list):
            for host in hosts:
                eucahosts[host.hostname] = host
        elif isinstance(hosts, EucaHost):
            eucahosts[hosts.hostname] = hosts

        if not isinstance(eucahosts, dict):
            raise ValueError(
                "show_machine_mappings requires dict example: "
                '{"host ip":[host objs]}, got:"{0}/{1}"'.format(eucahosts, type(eucahosts))
            )
        # To format the tables services, print them all at once and then sort the table
        # rows string into the machines columns
        for hostip, host in eucahosts.iteritems():
            for serv in host.services:
                if update:
                    serv.update()
                total.append(serv)
                if serv.child_services:
                    total.extend(serv.child_services)
        # Create a table showing the service states, grab the first 3 columns
        # for type, name, state, and zone
        servpt = self.show_services(total, print_table=False)
        # Get a subset of the show services fields...
        if serv_columns is None:
            fields = servpt._field_names[0:4]
        else:
            fields = servpt._fields_names[serv_columns]
        serv_lines = servpt.get_string(border=0, padding_width=2, fields=fields).splitlines()
        header = serv_lines[0]
        ansi_escape = re.compile(r"\x1b[^m]*m")
        # Now build the machine table...
        threads = []
        hostlock = threading.Lock()

        # Method to allow host info to be gathered concurrently
        def add_host(hostip, host, self=self):
            assert isinstance(host, EucaHost)
            servbuf = header + "\n"
            mservices = []
            # Get the child services (ie for UFS)
            for serv in host.services:
                mservices.append(serv)
                mservices.extend(serv.child_services)
            for serv in mservices:
                for line in serv_lines:
                    # Remove the ansi markup for parsing purposes, but leave it in the
                    # displayed line
                    clean_line = ansi_escape.sub("", line)
                    splitline = clean_line.split()
                    if len(splitline) < 2:
                        continue
                    line_type = splitline[0]
                    line_name = splitline[1]
                    # Pull matching lines out of the pre-formatted service table...
                    if (
                        splitline
                        and re.match("^{0}$".format(serv.type), line_type)
                        and re.match("^{0}$".format(serv.name), line_name)
                    ):
                        # Add this line to the services to be displayed for this machine
                        if line_name not in servbuf:
                            servbuf += line + "\n"
                if serv.type == "node":
                    if getattr(serv, "instances", None):
                        if serv.instances:
                            vm_pt = PrettyTable(
                                [
                                    markup("INSTANCES", [1, 4]),
                                    markup("STATE:", [1, 4]),
                                    markup("VMTYPE:", [1, 4]),
                                    markup("ROOT_DEV:", [1, 4]),
                                ]
                            )
                            vm_pt.align = "l"
                            vm_pt.border = 1
                            vm_pt.vrules = 2
                            vm_pt.hrules = 0
                            for x in serv.instances:
                                vm_pt.add_row(
                                    [
                                        x.id,
                                        markup(x.state, self.vm_state_markup(x.state)),
                                        x.instance_type,
                                        x.root_device_type,
                                    ]
                                )
                            servbuf += "{0}\n".format(vm_pt)
                    av_pt = host.helpers.node_controller.show_availability_for_node(print_table=False)
                    servbuf += av_pt.get_string()
            ps_sum_pt = host.show_euca_process_summary(print_table=False)
            servbuf += "\n" + ps_sum_pt.get_string(border=1, vrules=2, hrules=0)
            host_info = markup("Euca Versions:").ljust(machine_hdr[1])
            host_info += "Cloud: {0}".format(host.get_eucalyptus_version()).ljust(machine_hdr[1])
            host_info += "2ools: {0}".format(host.get_euca2ools_version()).ljust(machine_hdr[1])
            host_info += markup("Hostname:").ljust(machine_hdr[1])
            host_info += str(host.hostname).ljust(machine_hdr[1])
            sys_pt = host.show_sys_info(print_table=False)
            host_info += "{0}".format(sys_pt)
            with hostlock:
                pt.add_row(
                    [
                        markup("HOST:") + markup(hostip, [1, 94]),
                        markup("EUCALYPTUS SERVICES:")
                        + markup("[ {0} ]".format(" ".join(str(x) for x in host.euca_service_codes)), [1, 34]),
                    ]
                )
                pt.add_row([host_info, servbuf])

        for hostip, host in eucahosts.iteritems():
            t = threading.Thread(target=add_host, args=(hostip, host))
            t.start()
            threads.append(t)
        for t in threads:
            t.join()
        if save_file:
            with open(save_file, "w") as sf:
                sf.write("\n{0}\n".format(pt.get_string()))
        if print_table:
            # print_method("\n{0}\n".format(pt.get_string(sortby=pt.field_names[1])))
            print_method("\n{0}\n".format(pt.get_string()))
        else:
            return pt
 def status_log(self, msg):
     return self.log.info(markup(msg, 
                                 markups=[ForegroundColor.WHITE, 
                                          BackGroundColor.BG_GREEN, 
                                          TextStyle.BOLD]))
Exemple #48
0
 def menu_summary(self, args):
     """Prints Summary of commands and sub-menu items"""
     menu_color = [1, 4, 34]  #  bold, underlined, blue
     prevname = None
     names = self.get_names()
     menu_items = []
     maxlen = 0
     main_pt = pt = PrettyTable(['MAIN'])
     main_pt.header = False
     main_pt.border = False
     main_pt.align = 'l'
     sub_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     base_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     current_pt = PrettyTable(['COMMAND', 'DESCRIPTION'])
     for table in [sub_pt, base_pt, current_pt]:
         table.header = False
         table.border = False
         table.align = 'l'
     #Sort out methods that begin with 'do_' as menu items...
     for name in names:
         if name[:3] == 'do_':
             if name == prevname:
                 continue
             prevname = name
             if len(name[3:]) > maxlen:
                 maxlen = len(name[3:])
             menu_items.append(name)
     #Sort out menu items into: submenus, local commands, and globals
     for name in menu_items:
         cmd = str(name[3:])
         cmd_method = getattr(self, name)
         doc = str(cmd_method.__doc__) or ''
         doc = doc.lstrip().splitlines()[0].strip()
         if hasattr(cmd_method, '__submenu__'):
             if hasattr(BaseMenu, name):
                 base_pt.add_row([
                     "\t{0}".format(markup(cmd, markups=menu_color)),
                     markup(doc, markups=menu_color)
                 ])
             else:
                 current_pt.add_row([
                     "\t{0}".format(markup(cmd, markups=menu_color)),
                     markup(doc, markups=menu_color)
                 ])
         else:
             if hasattr(BaseMenu, name):
                 base_pt.add_row(
                     ["\t{0}".format(yellow(cmd, bold=True)), doc])
             else:
                 current_pt.add_row(
                     ["\t{0}".format(yellow(cmd, bold=True)), doc])
     buf = "{0}\n".format(
         cyan('*** ' + self.name.upper() + ' OPTIONS ***', bold=True))
     if current_pt._rows:
         # Add blank line for formatting, separate menu items from commands
         #current_pt.add_row(["\t{0}".format(yellow(" ", bold=True)), ""])
         buf += "{0}\n".format(current_pt.get_string(sortby='COMMAND'))
     if sub_pt._rows:
         buf += "{0}\n".format(sub_pt)
     if base_pt._rows:
         buf += "{0}\n{1}\n".format(
             cyan('*** BASE COMMANDS ***', bold=True), base_pt)
     main_pt.add_row([buf])
     self.oprint("{0}".format(main_pt))