ResultSets.parseInstanceState() - Code Metrics - Inspection of "Aws elb" - StackStorm/st2contrib - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#640)

unknown

created 2016-12-15 17:21 UTC

ResultSets.parseInstanceState() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
dl	0
loc	2
rs	10
c	1
b	0
f	0

import six

from boto import ec2
from boto import route53
from boto import cloudformation
from boto import rds
from boto.s3.bucket import Bucket


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 = [
        '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, ec2.instance.Reservation):
            return self.parseReservation(output)
        elif isinstance(output, ec2.instance.Instance):
            return self.parseInstance(output)
        elif isinstance(output, ec2.volume.Volume):
            return self.parseVolume(output)
        elif isinstance(output, ec2.blockdevicemapping.BlockDeviceType):
            return self.parseBlockDeviceType(output)
        elif isinstance(output, ec2.zone.Zone):
            return self.parseEC2Zone(output)
        elif isinstance(output, ec2.address.Address):
            return self.parseAddress(output)
        elif isinstance(output, ec2.tag.Tag):
            return self.parseTag(output)
        elif isinstance(output, ec2.ec2object.EC2Object):
            return self.parseEC2Object(output)
        elif isinstance(output, ec2.elb.loadbalancer.LoadBalancer):
            return self.parseLoadbalancers(output)
        elif isinstance(output, ec2.elb.instancestate.InstanceState):
            return self.parseInstanceState(output)
        elif isinstance(output, route53.record.Record):
            return self.parseRecord(output)
        elif isinstance(output, route53.zone.Zone):
            return self.parseR53Zone(output)
        elif isinstance(output, route53.status.Status):
            return self.parseR53Status(output)
        elif isinstance(output, cloudformation.stack.Stack):
            return self.parseStackObject(output)
        elif isinstance(output, rds.dbinstance.DBInstance):
            return self.parseDBInstanceObject(output)
        elif isinstance(output, Bucket):
            return self.parseBucket(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)}
        elif isinstance(output, unicode):

            return 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 parseLoadbalancers(self, output):
        return output.__str__()

    def parseInstanceState(self, output):
        return output.__str__()

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

StackStorm / st2contrib

Pull Request — master (#640)

ResultSets.parseInstanceState() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like