def _plan_sqseventsource()

in chalice/deploy/planner.py [0:0]
72 lines of code
3 McCabe index (conditional complexity)

    def _plan_sqseventsource(self, resource):
        # type: (models.SQSEventSource) -> Sequence[InstructionMsg]
        queue_arn_varname = '%s_queue_arn' % resource.resource_name
        uuid_varname = '%s_uuid' % resource.resource_name
        function_arn = Variable(
            '%s_lambda_arn' % resource.lambda_function.resource_name
        )
        if not isinstance(resource.queue, models.QueueARN):
            instruction_for_queue_arn = self._arn_parse_instructions(
                function_arn)
            instruction_for_queue_arn.append(
                models.StoreValue(
                    name=queue_arn_varname,
                    value=StringFormat(
                        'arn:{partition}:sqs:{region_name}:{account_id}:%s' % (
                            resource.queue
                        ),
                        ['partition', 'region_name', 'account_id'],
                    ),
                )
            )
            queue_name = resource.queue
        else:
            instruction_for_queue_arn = [
                models.StoreValue(
                    name=queue_arn_varname,
                    value=resource.queue.arn,
                )
            ]
            queue_name = resource.queue.queue_name
        if self._remote_state.resource_exists(resource):
            deployed = self._remote_state.resource_deployed_values(resource)
            uuid = deployed['event_uuid']
            return instruction_for_queue_arn + [
                models.APICall(
                    method_name='update_lambda_event_source',
                    params={
                        'event_uuid': uuid,
                        'batch_size': resource.batch_size,
                        'maximum_batching_window_in_seconds':
                            resource.maximum_batching_window_in_seconds,
                        'maximum_concurrency': resource.maximum_concurrency
                    }
                )
            ] + self._batch_record_resource(
                'sqs_event', resource.resource_name, {
                    'queue_arn': deployed['queue_arn'],
                    'event_uuid': uuid,
                    'queue': queue_name,
                    'lambda_arn': deployed['lambda_arn'],
                }
            )
        return instruction_for_queue_arn + [
            (models.APICall(
                method_name='create_lambda_event_source',
                params={'event_source_arn': Variable(queue_arn_varname),
                        'batch_size': resource.batch_size,
                        'maximum_batching_window_in_seconds':
                            resource.maximum_batching_window_in_seconds,
                        'maximum_concurrency': resource.maximum_concurrency,
                        'function_name': function_arn},
                output_var=uuid_varname,
            ), 'Subscribing %s to SQS queue %s\n'
                % (resource.lambda_function.function_name, resource.queue)
            ),
        ] + self._batch_record_resource(
            'sqs_event', resource.resource_name, {
                'queue_arn': Variable(queue_arn_varname),
                'event_uuid': Variable(uuid_varname),
                'queue': queue_name,
                'lambda_arn': Variable(function_arn.name)
            }
        )