def _create_state_machine_from_meta()

in syndicate/core/resources/step_functions_resource.py [0:0]

• 57 lines of code
• 10 McCabe index (conditional complexity)

    def _create_state_machine_from_meta(self, name, meta):
        arn = self._build_sm_arn(name, self.region)
        response = self.sf_conn.describe_state_machine(arn)
        if response:
            _LOG.warn('State machine %s exists', name)
            return {
                arn: build_description_obj(response, name, meta)
            }

        iam_role = meta['iam_role']
        role_arn = self.iam_conn.check_if_role_exists(iam_role)
        if not role_arn:
            raise AssertionError(
                'IAM role {0} does not exist.'.format(iam_role))

        # check resource exists and get arn
        definition = meta['definition']
        definition_copy = definition.copy()
        for key in definition['States']:
            definition_meta = definition['States'][key]
            if definition_meta.get('Lambda'):
                lambda_name = definition_meta['Lambda']
                # alias has a higher priority than version in arn resolving
                lambda_version = definition_meta.get('Lambda_version')
                lambda_alias = definition_meta.get('Lambda_alias')
                lambda_arn = self.resolve_lambda_arn_by_version_and_alias(
                    lambda_name,
                    lambda_version,
                    lambda_alias)
                self.__remove_key_from_dict(definition_copy['States'][key],
                                            'Lambda')
                self.__remove_key_from_dict(definition_copy['States'][key],
                                            'Lambda_version')
                self.__remove_key_from_dict(definition_copy['States'][key],
                                            'Lambda_alias')

                definition_copy['States'][key]['Resource'] = lambda_arn

            if definition_meta.get('Activity'):
                activity_name = definition_meta['Activity']
                activity_arn = 'arn:aws:states:{0}:{1}:activity:{2}'.format(
                    self.region, self.account_id, activity_name)
                activity_info = self.sf_conn.describe_activity(
                    arn=activity_arn)
                if not activity_info:
                    raise AssertionError('Activity does not exists: %s',
                                         activity_name)
                activity_arn = activity_info['activityArn']
                del definition_copy['States'][key]['Activity']
                definition_copy['States'][key]['Resource'] = activity_arn
        machine_info = self.sf_conn.create_state_machine(
            machine_name=name,
            role_arn=role_arn,
            definition=definition_copy,
            tags=meta.get('tags'))

        event_sources = meta.get('event_sources')
        if event_sources:
            for trigger_meta in event_sources:
                trigger_type = trigger_meta['resource_type']
                func = self.CREATE_TRIGGER[trigger_type]
                func(name, trigger_meta)
        _LOG.info('Created state machine %s.', machine_info['stateMachineArn'])
        return self.describe_step_function(name=name, meta=meta, arn=arn)