def slurp(self):
        """
        :returns: item_list - list of RDS Security Groups.
        :returns: exception_map - A dict where the keys are a tuple containing the
            location of the exception and the value is the actual exception

        """
        self.prep_for_slurp()

        item_list = []
        exception_map = {}
        from security_monkey.common.sts_connect import connect
        for account in self.accounts:
            for region in regions():
                app.logger.debug("Checking {}/{}/{}".format(self.index, account, region.name))

                sgs = []
                try:
                    rds = connect(account, 'rds', region=region)

                    marker = None
                    while True:
                        response = self.wrap_aws_rate_limited_call(
                            rds.get_all_dbsecurity_groups,
                            marker=marker
                        )

                        sgs.extend(response)
                        if response.marker:
                            marker = response.marker
                        else:
                            break

                except Exception as e:
                    if region.name not in TROUBLE_REGIONS:
                        exc = BotoConnectionIssue(str(e), self.index, account, region.name)
                        self.slurp_exception((self.index, account, region.name), exc, exception_map)
                    continue

                app.logger.debug("Found {} {}".format(len(sgs), self.i_am_plural))
                for sg in sgs:

                    if self.check_ignore_list(sg.name):
                        continue

                    name = sg.name
                    vpc_id = None
                    if hasattr(sg, 'VpcId'):
                        vpc_id = sg.VpcId
                        name = "{} (in {})".format(sg.name, vpc_id)

                    item_config = {
                        "name": sg.name,
                        "description": sg.description,
                        "owner_id": sg.owner_id,
                        "region": region.name,
                        "ec2_groups": [],
                        "ip_ranges": [],
                        "vpc_id": vpc_id
                    }

                    for ipr in sg.ip_ranges:
                        ipr_config = {
                            "cidr_ip": ipr.cidr_ip,
                            "status": ipr.status,
                        }
                        item_config["ip_ranges"].append(ipr_config)
                    item_config["ip_ranges"] = sorted(item_config["ip_ranges"])

                    for ec2_sg in sg.ec2_groups:
                        ec2sg_config = {
                            "name": ec2_sg.name,
                            "owner_id": ec2_sg.owner_id,
                            "Status": ec2_sg.Status,
                        }
                        item_config["ec2_groups"].append(ec2sg_config)
                    item_config["ec2_groups"] = sorted(item_config["ec2_groups"])

                    item = RDSSecurityGroupItem(region=region.name, account=account, name=name, config=item_config)
                    item_list.append(item)

        return item_list, exception_map
dataset/ETHPy150Open Netflix/security_monkey/security_monkey/watchers/rds_security_group.py/RDSSecurityGroup.slurp/original