ResultSets.parseDBInstanceObject() - Code Metrics - Inspection of "parse the boto.rds.dbinstance.DBInstance object" - StackStorm/st2contrib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#479)

unknown

created 2016-04-15 20:15 UTC

ResultSets.parseDBInstanceObject() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	2
dl	0
loc	3
rs	10

import boto
import six


class FieldLists():
    ADDRESS = [
        'allocation_id',
        'association_id',
        'domain',
        'instance_id',
        'network_interface_id',
        'network_interface_owner_id',
        'private_ip_address',
        'public_ip'
    ]

    BLOCK_DEVICE_TYPE = [
        'attach_time',
        'delete_on_termination',
        'encrypted',
        'ephemeral_name',
        'iops',
        'size',
        'snapshot_id',
        'status',
        'volume_id',
        'volume_type'
    ]

    BUCKET = [
        'connection',
        'creation_date',
        'LoggingGroup',
        'name'
    ]

    EC2ZONE = [
        'messages',
        'name',
        'region_name',
        'state'
    ]

    INSTANCE = [
        'ami_launch_index',
        'architecture',
        'hypervisor',
        'id',
        'image_id',
        'instance_type',
        'ip_address',
        'kernel',
        'key_name',
        'launch_time',
        'monitored',
        'monitoring_state',
        'placement',
        'placement_group',
        'placement_tenancy',
        'platform',
        'previous_state',
        'previous_state_code',
        'private_dns_name',
        'private_ip_address',
        'public_dns_name',
        'ramdisk',
        'root_device_name',
        'root_device_type',
        'spot_instance_request_id',
        'state',
        'state_code',
        'state_reason',
        'subnet_id',
        'tags',
        'virtualization_type',
        'vpc_id',
    ]

    RECORD = [
        'alias_dns_name',
        'alias_evaluate_target_health',
        'alias_hosted_zone_id',
        'failover',
        'health_check',
        'identifier',
        'name',
        'region',
        'resource_records',
        'ttl',
        'type',
        'weight'
    ]

    R53ZONE = [
        'callerreference',
        'config',
        'id',
        'name',
        'resourcerecordsetcount'
    ]

    R53STATUS = [
        'comment',
        'id',
        'status',
        'submittedat'
    ]

    VOLUME = [
        'create_time',
        'encrypted',
        'id',
        'iops',
        'size',
        'snapshot_id',
        'status',
        'type',
        'zone'
    ]

    TAG = [
        'name',
        'value',
        'res_type',
        'res_id'
    ]

    STACK = [
        'creation_time',
        'outputs',
        'parameters',
        'stack_id',
        'description',
        'tags',
        'capabilities',
        'stack_status'
    ]

    DBINSTANCE = [
        'endpoint',
        'engine',
        'engine_version',
        'id',
        'iops',
        '_port',
        'status',
        'allocated_storage',
        'master_username',
        'multi_az',
        'instance_class',
        'create_time',
        'availability_zone',
        'PubliclyAccessible'
    ]


class ResultSets(object):

    def __init__(self):
        self.foo = ''

    def selector(self, output):
        if isinstance(output, boto.ec2.instance.Reservation):
            return self.parseReservation(output)
        elif isinstance(output, boto.ec2.instance.Instance):
            return self.parseInstance(output)
        elif isinstance(output, boto.ec2.volume.Volume):
            return self.parseVolume(output)
        elif isinstance(output, boto.ec2.blockdevicemapping.BlockDeviceType):
            return self.parseBlockDeviceType(output)
        elif isinstance(output, boto.ec2.zone.Zone):
            return self.parseEC2Zone(output)
        elif isinstance(output, boto.ec2.address.Address):
            return self.parseAddress(output)
        elif isinstance(output, boto.route53.record.Record):
            return self.parseRecord(output)
        elif isinstance(output, boto.route53.zone.Zone):
            return self.parseR53Zone(output)
        elif isinstance(output, boto.route53.status.Status):
            return self.parseR53Status(output)
        elif isinstance(output, boto.ec2.tag.Tag):
            return self.parseTag(output)
        elif isinstance(output, boto.ec2.ec2object.EC2Object):
            return self.parseEC2Object(output)
        elif isinstance(output, boto.cloudformation.stack.Stack):
            return self.parseStackObject(output)
        elif isinstance(output, boto.rds.dbinstance.DBInstance):
            return self.parseDBInstanceObject(output)
        else:
            return output

    def formatter(self, output):
        if isinstance(output, list):
            return [self.formatter(item) for item in output]
        elif isinstance(output, dict):
            return {key: self.formatter(value) for key, value in six.iteritems(output)}
        else:
            return self.selector(output)

    def parseReservation(self, output):
        instance_list = []
        for instance in output.instances:
            instance_data = self.parseInstance(instance)
            instance_data['owner_id'] = output.owner_id
            instance_list.append(instance_data)
        return instance_list

    def parseAddress(self, output):
        instance_data = {field: getattr(output, field) for field in FieldLists.ADDRESS}
        return instance_data

    def parseInstance(self, output):
        instance_data = {field: getattr(output, field) for field in FieldLists.INSTANCE}
        return instance_data

    def parseVolume(self, output):
        volume_data = {field: getattr(output, field) for field in FieldLists.VOLUME}
        return volume_data

    def parseBlockDeviceType(self, output):
        data = {field: getattr(output, field) for field in FieldLists.BLOCK_DEVICE_TYPE}
        return data

    def parseEC2Zone(self, output):
        zone_data = {field: getattr(output, field) for field in FieldLists.EC2ZONE}
        return zone_data

    def parseRecord(self, output):
        record_data = {field: getattr(output, field) for field in FieldLists.RECORD}
        return record_data

    def parseR53Zone(self, output):
        zone_data = {field: getattr(output, field) for field in FieldLists.R53ZONE}
        return zone_data

    def parseR53Status(self, output):
        status_data = {field: getattr(output, field) for field in FieldLists.R53STATUS}
        return status_data

    def parseBucket(self, output):
        bucket_data = {field: getattr(output, field) for field in FieldLists.BUCKET}
        return bucket_data

    def parseTag(self, output):
        tag_data = {field: getattr(output, field) for field in FieldLists.TAG}
        return tag_data

    def parseStackObject(self, output):
        stack_data = {field: getattr(output, field) for field in FieldLists.STACK}
        return stack_data

    def parseDBInstanceObject(self, output):
        dbinstance_data = {field: getattr(output, field) for field in FieldLists.DBINSTANCE}
        return dbinstance_data

    def parseEC2Object(self, output):
        # Looks like everything that is an EC2Object pretty much only has these extra
        # 'unparseable' properties so handle region and connection specially.
        output = vars(output)
        del output['connection']
        # special handling for region since name here is better than id.
        region = output.get('region', None)
        output['region'] = region.name if region else ''
        # now anything that is an EC2Object get some special marshalling care.
        for k, v in six.iteritems(output):
            if isinstance(v, boto.ec2.ec2object.EC2Object):
                # Better not to assume each EC2Object has an id. If not found
                # resort to the str of the object which should have something meaningful.
                output[k] = getattr(v, 'id', str(v))
            # Generally unmarshallable object might be hiding in list so better to
            if isinstance(v, list):
                v_list = []
                for item in v:
                    # avoid touching the basic types.
                    if isinstance(item, (basestring, bool, int, long, float)):

                        v_list.append(v)
                    else:
                        v_list.append(str(item))
                output[k] = v_list
        return output


1			import boto
2			import six
3
4
5			class FieldLists():
6			ADDRESS = [
7			'allocation_id',
8			'association_id',
9			'domain',
10			'instance_id',
11			'network_interface_id',
12			'network_interface_owner_id',
13			'private_ip_address',
14			'public_ip'
15			]
16
17			BLOCK_DEVICE_TYPE = [
18			'attach_time',
19			'delete_on_termination',
20			'encrypted',
21			'ephemeral_name',
22			'iops',
23			'size',
24			'snapshot_id',
25			'status',
26			'volume_id',
27			'volume_type'
28			]
29
30			BUCKET = [
31			'connection',
32			'creation_date',
33			'LoggingGroup',
34			'name'
35			]
36
37			EC2ZONE = [
38			'messages',
39			'name',
40			'region_name',
41			'state'
42			]
43
44			INSTANCE = [
45			'ami_launch_index',
46			'architecture',
47			'hypervisor',
48			'id',
49			'image_id',
50			'instance_type',
51			'ip_address',
52			'kernel',
53			'key_name',
54			'launch_time',
55			'monitored',
56			'monitoring_state',
57			'placement',
58			'placement_group',
59			'placement_tenancy',
60			'platform',
61			'previous_state',
62			'previous_state_code',
63			'private_dns_name',
64			'private_ip_address',
65			'public_dns_name',
66			'ramdisk',
67			'root_device_name',
68			'root_device_type',
69			'spot_instance_request_id',
70			'state',
71			'state_code',
72			'state_reason',
73			'subnet_id',
74			'tags',
75			'virtualization_type',
76			'vpc_id',
77			]
78
79			RECORD = [
80			'alias_dns_name',
81			'alias_evaluate_target_health',
82			'alias_hosted_zone_id',
83			'failover',
84			'health_check',
85			'identifier',
86			'name',
87			'region',
88			'resource_records',
89			'ttl',
90			'type',
91			'weight'
92			]
93
94			R53ZONE = [
95			'callerreference',
96			'config',
97			'id',
98			'name',
99			'resourcerecordsetcount'
100			]
101
102			R53STATUS = [
103			'comment',
104			'id',
105			'status',
106			'submittedat'
107			]
108
109			VOLUME = [
110			'create_time',
111			'encrypted',
112			'id',
113			'iops',
114			'size',
115			'snapshot_id',
116			'status',
117			'type',
118			'zone'
119			]
120
121			TAG = [
122			'name',
123			'value',
124			'res_type',
125			'res_id'
126			]
127
128			STACK = [
129			'creation_time',
130			'outputs',
131			'parameters',
132			'stack_id',
133			'description',
134			'tags',
135			'capabilities',
136			'stack_status'
137			]
138
139			DBINSTANCE = [
140			'endpoint',
141			'engine',
142			'engine_version',
143			'id',
144			'iops',
145			'_port',
146			'status',
147			'allocated_storage',
148			'master_username',
149			'multi_az',
150			'instance_class',
151			'create_time',
152			'availability_zone',
153			'PubliclyAccessible'
154			]
155
156
157			class ResultSets(object):
158
159			def __init__(self):
160			self.foo = ''
161
162			def selector(self, output):
163			if isinstance(output, boto.ec2.instance.Reservation):
164			return self.parseReservation(output)
165			elif isinstance(output, boto.ec2.instance.Instance):
166			return self.parseInstance(output)
167			elif isinstance(output, boto.ec2.volume.Volume):
168			return self.parseVolume(output)
169			elif isinstance(output, boto.ec2.blockdevicemapping.BlockDeviceType):
170			return self.parseBlockDeviceType(output)
171			elif isinstance(output, boto.ec2.zone.Zone):
172			return self.parseEC2Zone(output)
173			elif isinstance(output, boto.ec2.address.Address):
174			return self.parseAddress(output)
175			elif isinstance(output, boto.route53.record.Record):
176			return self.parseRecord(output)
177			elif isinstance(output, boto.route53.zone.Zone):
178			return self.parseR53Zone(output)
179			elif isinstance(output, boto.route53.status.Status):
180			return self.parseR53Status(output)
181			elif isinstance(output, boto.ec2.tag.Tag):
182			return self.parseTag(output)
183			elif isinstance(output, boto.ec2.ec2object.EC2Object):
184			return self.parseEC2Object(output)
185			elif isinstance(output, boto.cloudformation.stack.Stack):
186			return self.parseStackObject(output)
187			elif isinstance(output, boto.rds.dbinstance.DBInstance):
188			return self.parseDBInstanceObject(output)
189			else:
190			return output
191
192			def formatter(self, output):
193			if isinstance(output, list):
194			return [self.formatter(item) for item in output]
195			elif isinstance(output, dict):
196			return {key: self.formatter(value) for key, value in six.iteritems(output)}
197			else:
198			return self.selector(output)
199
200			def parseReservation(self, output):
201			instance_list = []
202			for instance in output.instances:
203			instance_data = self.parseInstance(instance)
204			instance_data['owner_id'] = output.owner_id
205			instance_list.append(instance_data)
206			return instance_list
207
208			def parseAddress(self, output):
209			instance_data = {field: getattr(output, field) for field in FieldLists.ADDRESS}
210			return instance_data
211
212			def parseInstance(self, output):
213			instance_data = {field: getattr(output, field) for field in FieldLists.INSTANCE}
214			return instance_data
215
216			def parseVolume(self, output):
217			volume_data = {field: getattr(output, field) for field in FieldLists.VOLUME}
218			return volume_data
219
220			def parseBlockDeviceType(self, output):
221			data = {field: getattr(output, field) for field in FieldLists.BLOCK_DEVICE_TYPE}
222			return data
223
224			def parseEC2Zone(self, output):
225			zone_data = {field: getattr(output, field) for field in FieldLists.EC2ZONE}
226			return zone_data
227
228			def parseRecord(self, output):
229			record_data = {field: getattr(output, field) for field in FieldLists.RECORD}
230			return record_data
231
232			def parseR53Zone(self, output):
233			zone_data = {field: getattr(output, field) for field in FieldLists.R53ZONE}
234			return zone_data
235
236			def parseR53Status(self, output):
237			status_data = {field: getattr(output, field) for field in FieldLists.R53STATUS}
238			return status_data
239
240			def parseBucket(self, output):
241			bucket_data = {field: getattr(output, field) for field in FieldLists.BUCKET}
242			return bucket_data
243
244			def parseTag(self, output):
245			tag_data = {field: getattr(output, field) for field in FieldLists.TAG}
246			return tag_data
247
248			def parseStackObject(self, output):
249			stack_data = {field: getattr(output, field) for field in FieldLists.STACK}
250			return stack_data
251
252			def parseDBInstanceObject(self, output):
253			dbinstance_data = {field: getattr(output, field) for field in FieldLists.DBINSTANCE}
254			return dbinstance_data
255
256			def parseEC2Object(self, output):
257			# Looks like everything that is an EC2Object pretty much only has these extra
258			# 'unparseable' properties so handle region and connection specially.
259			output = vars(output)
260			del output['connection']
261			# special handling for region since name here is better than id.
262			region = output.get('region', None)
263			output['region'] = region.name if region else ''
264			# now anything that is an EC2Object get some special marshalling care.
265			for k, v in six.iteritems(output):
266			if isinstance(v, boto.ec2.ec2object.EC2Object):
267			# Better not to assume each EC2Object has an id. If not found
268			# resort to the str of the object which should have something meaningful.
269			output[k] = getattr(v, 'id', str(v))
270			# Generally unmarshallable object might be hiding in list so better to
271			if isinstance(v, list):
272			v_list = []
273			for item in v:
274			# avoid touching the basic types.
275			if isinstance(item, (basestring, bool, int, long, float)):
			0 ignored issues – show Comprehensibility Best Practice introduced 2016-02-01 22:20 UTC by Report Bug Copy Issue Report Undefined variable 'basestring' Loading history... Comprehensibility Best Practice introduced 2016-02-01 22:20 UTC by Report Bug Copy Issue Report Undefined variable 'long' Loading history...
276			v_list.append(v)
277			else:
278			v_list.append(str(item))
279			output[k] = v_list
280			return output
281

StackStorm / st2contrib

Pull Request — master (#479)

ResultSets.parseDBInstanceObject() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like