def _process_asg()

in adjust_schedule_function/lib/processors/autoscaling.py [0:0]

• 54 lines of code
• 9 McCabe index (conditional complexity)

    def _process_asg(self, asg):
        result = []
        asg_name = asg['AutoScalingGroupName']

        print("Processing ASG '{}'".format(asg_name))

        if utils.get_tag_by_key(asg['Tags'], self._get_enabled_tag()) == None:
            print("Skipping: ASG '{}' is not enabled (missing tag '{}')".format(asg_name,
                                                                                self._get_enabled_tag()))
            return result

        local_timezone = utils.get_tag_by_key(asg['Tags'], self._get_local_timezone_tag())
        if not local_timezone:
            print("Skipping: ASG '{}' has no timezone defined (missing tag '{}')".format(asg_name,
                                                                                         self._get_local_timezone_tag()))
            return result

        scheduled_actions = self._asg_service.get_asg_scheduled_actions(asg_name)
        scheduled_action_updates = []

        for action in scheduled_actions:
            action_name = action['ScheduledActionName']
            current_recurrence = action['Recurrence']

            local_time_tag_key = self._get_local_time_tag() + ':' + action_name
            local_time = utils.get_tag_by_key(asg['Tags'], local_time_tag_key)
            if not local_time:
                print("Skipping: action '{}' does not have local time tag (missing tag '{}')".format(action_name, local_time_tag_key))
                continue

            print("Processing action '{}'".format(action_name))

            correct_recurrence = self._recurrence_calculator.calculate_recurrence(current_recurrence,
                                                                                  local_time,
                                                                                  local_timezone)
            if correct_recurrence != current_recurrence:
                print("Calculated recurrence '{}' does not match current recurrence '{}'. This action will be updated.".format(correct_recurrence, current_recurrence))
                scheduled_action_updates.append({
                    'ScheduledActionName': action_name,
                    'Recurrence': correct_recurrence,
                    # Need to specify one of min, max or desired
                    'DesiredCapacity': action['DesiredCapacity']
                })

                result.append({
                    'Type': 'AutoScalingGroupScalingPolicy',
                    'ResourceName': asg_name,
                    'ResourceArn': asg['AutoScalingGroupARN'],
                    'OriginalRecurrence': current_recurrence,
                    'NewRecurrence': correct_recurrence,
                    'LocalTime': local_time,
                    'LocalTimezone': local_timezone,
                    'AdditionalDetails': {'ActionName': action_name}
                })

        if not len(scheduled_action_updates):
            print("No scheduled actions need to be updated for ASG '{}'".format(asg_name))
        else:
            print("There are actions which need to be updated. Updating them now.")
            update_response = self._asg_service.update_asg_scheduled_actions(asg_name,
                                                                            scheduled_action_updates)

            if len(update_response['FailedScheduledUpdateGroupActions']):
                print(update_response['FailedScheduledUpdateGroupActions'])
                raise Exception('{} actions failed to update'.format(len(update_response['FailedScheduledUpdateGroupActions'])))

        return result