def do_secgroup_list_rules(cs, args):
    """Lists all rules for a security group."""
    sec_grp = cs.security_groups.get(args.security_group)
    rules = sec_grp._info['rules']
    utils.print_list(
        rules, ['id', 'protocol', 'from_port', 'to_port', 'cidr'],
        obj_is_dict=True)

def do_limit_list(cs, args):
    """Lists the limits for a tenant."""
    limits = cs.limits.list()
    # Pop the first one, its absolute limits
    absolute = limits.pop(0)
    _print_object(absolute)
    utils.print_list(limits, ["value", "verb", "remaining", "unit"])

def do_secgroup_add_rule(cs, args):
    """Creates a security group rule."""
    rules = cs.security_group_rules.create(args.security_group, args.cidr)

    utils.print_list(
        rules, ["id", "security_group_id", "protocol", "from_port", "to_port", "cidr", "created"], obj_is_dict=True
    )

def do_limit_list(cs, args):
    """Lists the limits for a tenant."""
    limits = cs.limits.list()
    # Pop the first one, its absolute limits
    absolute = limits.pop(0)
    _print_instance(absolute)
    utils.print_list(limits, ['value', 'verb', 'remaining', 'unit'])

def do_backup_list(cs, args):
    """Lists available backups."""
    wrapper = cs.backups.list(limit=args.limit, datastore=args.datastore)
    backups = wrapper.items
    while wrapper.next and not args.limit:
        wrapper = cs.backups.list(marker=wrapper.next)
        backups += wrapper.items
    utils.print_list(backups, ["id", "instance_id", "name", "status", "parent_id", "updated"], order_by="updated")

def do_secgroup_add_rule(cs, args):
    """Creates a security group rule."""
    rules = cs.security_group_rules.create(
        args.security_group, args.cidr)

    utils.print_list(rules, [
        'id', 'security_group_id', 'protocol',
        'from_port', 'to_port', 'cidr', 'created'], obj_is_dict=True)

def do_cluster_instances(cs, args):
    """Lists all instances of a cluster."""
    cluster = _find_cluster(cs, args.cluster)
    instances = cluster._info["instances"]
    for instance in instances:
        instance["flavor_id"] = instance["flavor"]["id"]
        if instance.get("volume"):
            instance["size"] = instance["volume"]["size"]
    utils.print_list(instances, ["id", "name", "flavor_id", "size", "status"], obj_is_dict=True)

def do_cluster_list(cs, args):
    """Lists all the clusters."""
    clusters = cs.clusters.list(limit=args.limit, marker=args.marker)

    for cluster in clusters:
        setattr(cluster, "datastore_version", cluster.datastore["version"])
        setattr(cluster, "datastore", cluster.datastore["type"])
        setattr(cluster, "task_name", cluster.task["name"])
    utils.print_list(clusters, ["id", "name", "datastore", "datastore_version", "task_name"])

def do_mgmt_cluster_instances(cs, args):
    """Lists all instances of a cluster."""
    cluster = cs.management_cluster_python_troveclient_ext.show(args.cluster)
    instances = cluster._info["instances"]
    for instance in instances:
        instance["flavor_id"] = instance["flavor"]["id"]
        if instance.get("volume"):
            instance["size"] = instance["volume"]["size"]
    utils.print_list(instances, ["id", "name", "type", "flavor_id", "size"], obj_is_dict=True)

def do_backup_list_instance(cs, args):
    """Lists available backups for an instance."""
    instance = _find_instance(cs, args.instance)
    wrapper = cs.instances.backups(instance, limit=args.limit)
    backups = wrapper.items
    while wrapper.next and not args.limit:
        wrapper = cs.instances.backups(instance, marker=wrapper.next)
        backups += wrapper.items
    utils.print_list(backups, ["id", "name", "status", "parent_id", "updated"], order_by="updated")

def do_secgroup_list(cs, args):
    """Lists all security groups."""
    wrapper = cs.security_groups.list()
    sec_grps = wrapper.items
    while wrapper.next:
        wrapper = cs.security_groups.list()
        sec_grps += wrapper.items

    utils.print_list(sec_grps, ["id", "name", "instance_id"])

def do_list(cs, args):
    """List all the instances."""
    instances = cs.instances.list()

    for instance in instances:
        setattr(instance, 'flavor_id', instance.flavor['id'])
        if hasattr(instance, 'volume'):
            setattr(instance, 'size', instance.volume['size'])
    utils.print_list(instances, ['id', 'name', 'status', 'flavor_id', 'size'])

def do_database_list(cs, args):
    """Lists available databases on an instance."""
    wrapper = cs.databases.list(args.instance)
    databases = wrapper.items
    while (wrapper.next):
        wrapper = cs.databases.list(args.instance, marker=wrapper.next)
        databases += wrapper.items

    utils.print_list(databases, ['name'])

def do_user_list(cs, args):
    """Lists the users for a instance."""
    wrapper = cs.users.list(args.instance)
    users = wrapper.items
    while (wrapper.next):
        wrapper = cs.users.list(args.instance, marker=wrapper.next)
        users += wrapper.items

    utils.print_list(users, ['name', 'host', 'databases'])

def do_secgroup_list(cs, args):
    """Lists all security groups."""
    wrapper = cs.security_groups.list()
    sec_grps = wrapper.items
    while (wrapper.next):
        wrapper = cs.security_groups.list()
        sec_grps += wrapper.items

    utils.print_list(sec_grps, ['id', 'name', 'rules', 'instance_id'])

def do_database_list(cs, args):
    """Lists available databases on an instance."""
    instance = _find_instance(cs, args.instance)
    wrapper = cs.databases.list(instance)
    databases = wrapper.items
    while wrapper.next:
        wrapper = cs.databases.list(instance, marker=wrapper.next)
        databases += wrapper.items

    utils.print_list(databases, ["name"])

def do_backup_list(cs, args):
    """Lists available backups."""
    wrapper = cs.backups.list(limit=args.limit)
    backups = wrapper.items
    while wrapper.next and not args.limit:
        wrapper = cs.backups.list(marker=wrapper.next)
        backups += wrapper.items
    utils.print_list(backups, ['id', 'instance_id', 'name',
                               'status', 'parent_id', 'updated'],
                     order_by='updated')

def do_user_list(cs, args):
    """Lists the users for an instance."""
    wrapper = cs.users.list(args.instance)
    users = wrapper.items
    while (wrapper.next):
        wrapper = cs.users.list(args.instance, marker=wrapper.next)
        users += wrapper.items
    for user in users:
        db_names = [db['name'] for db in user.databases]
        user.databases = ', '.join(db_names)
    utils.print_list(users, ['name', 'host', 'databases'])

def do_mgmt_cluster_list(cs, args):
    """List all clusters"""
    clusters = cs.management_cluster_python_troveclient_ext.index(deleted=args.deleted)
    for cluster in clusters:
        if hasattr(cluster, "datastore"):
            setattr(cluster, "datastore_version", cluster.datastore["version"])
            setattr(cluster, "datastore", cluster.datastore["type"])
        setattr(cluster, "task_name", cluster.task["name"])
    utils.print_list(
        clusters, ["id", "name", "tenant_id", "datastore", "datastore_version", "task_name", "created", "deleted_at"]
    )

def do_configuration_parameter_list(cs, args):
    """Lists available parameters for a configuration group."""
    if args.datastore:
        params = cs.configuration_parameters.parameters(args.datastore, args.datastore_version)
    elif utils.is_uuid_like(args.datastore_version):
        params = cs.configuration_parameters.parameters_by_version(args.datastore_version)
    else:
        raise exceptions.NoUniqueMatch(
            "The datastore name or id is required" " to retrieve the parameters for the" " configuration group by name."
        )
    utils.print_list(params, ["name", "type", "min_size", "max_size", "restart_required"])