github.com/GoogleCloudPlatform/terraformer@v0.8.18/providers/aws/lambda.go (about)

     1  // Copyright 2019 The Terraformer Authors.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package aws
    16  
    17  import (
    18  	"context"
    19  
    20  	"github.com/GoogleCloudPlatform/terraformer/terraformutils"
    21  	"github.com/aws/aws-sdk-go-v2/service/lambda"
    22  )
    23  
    24  var lambdaAllowEmptyValues = []string{"tags."}
    25  
    26  type LambdaGenerator struct {
    27  	AWSService
    28  }
    29  
    30  func (g *LambdaGenerator) InitResources() error {
    31  	config, e := g.generateConfig()
    32  	if e != nil {
    33  		return e
    34  	}
    35  	svc := lambda.NewFromConfig(config)
    36  
    37  	err := g.addFunctions(svc)
    38  	if err != nil {
    39  		return err
    40  	}
    41  	err = g.addEventSourceMappings(svc)
    42  	if err != nil {
    43  		return err
    44  	}
    45  	err = g.addLayerVersions(svc)
    46  	return err
    47  }
    48  
    49  func (g *LambdaGenerator) PostConvertHook() error {
    50  	for i, r := range g.Resources {
    51  		if _, exist := r.Item["environment"]; !exist {
    52  			continue
    53  		}
    54  		variables := g.Resources[i].Item["environment"].([]interface{})[0].(map[string]interface{})["variables"]
    55  		g.Resources[i].Item["environment"] = []interface{}{
    56  			map[string]interface{}{
    57  				"variables": []map[string]interface{}{variables.(map[string]interface{})},
    58  			},
    59  		}
    60  	}
    61  	for _, r := range g.Resources {
    62  		if r.InstanceInfo.Type != "aws_lambda_function_event_invoke_config" {
    63  			continue
    64  		}
    65  		if r.InstanceState.Attributes["maximum_event_age_in_seconds"] == "0" {
    66  			delete(r.Item, "maximum_event_age_in_seconds")
    67  		}
    68  	}
    69  	return nil
    70  }
    71  
    72  func (g *LambdaGenerator) addFunctions(svc *lambda.Client) error {
    73  	p := lambda.NewListFunctionsPaginator(svc, &lambda.ListFunctionsInput{})
    74  	for p.HasMorePages() {
    75  		page, err := p.NextPage(context.TODO())
    76  		if err != nil {
    77  			return err
    78  		}
    79  		for _, function := range page.Functions {
    80  			g.Resources = append(g.Resources, terraformutils.NewResource(
    81  				*function.FunctionArn,
    82  				*function.FunctionName,
    83  				"aws_lambda_function",
    84  				"aws",
    85  				map[string]string{
    86  					"function_name": *function.FunctionName,
    87  				},
    88  				lambdaAllowEmptyValues,
    89  				map[string]interface{}{},
    90  			))
    91  
    92  			pi := lambda.NewListFunctionEventInvokeConfigsPaginator(svc,
    93  				&lambda.ListFunctionEventInvokeConfigsInput{
    94  					FunctionName: function.FunctionName,
    95  				})
    96  			for pi.HasMorePages() {
    97  				piage, err := pi.NextPage(context.TODO())
    98  				if err != nil {
    99  					return err
   100  				}
   101  				for _, functionEventInvokeConfig := range piage.FunctionEventInvokeConfigs {
   102  					g.Resources = append(g.Resources, terraformutils.NewSimpleResource(
   103  						*function.FunctionArn,
   104  						"feic_"+*functionEventInvokeConfig.FunctionArn,
   105  						"aws_lambda_function_event_invoke_config",
   106  						"aws",
   107  						lambdaAllowEmptyValues,
   108  					))
   109  				}
   110  			}
   111  		}
   112  	}
   113  	return nil
   114  }
   115  
   116  func (g *LambdaGenerator) addEventSourceMappings(svc *lambda.Client) error {
   117  	p := lambda.NewListEventSourceMappingsPaginator(svc, &lambda.ListEventSourceMappingsInput{})
   118  	for p.HasMorePages() {
   119  		page, err := p.NextPage(context.TODO())
   120  		if err != nil {
   121  			return err
   122  		}
   123  		for _, mapping := range page.EventSourceMappings {
   124  			g.Resources = append(g.Resources, terraformutils.NewResource(
   125  				*mapping.UUID,
   126  				*mapping.UUID,
   127  				"aws_lambda_event_source_mapping",
   128  				"aws",
   129  				map[string]string{
   130  					"event_source_arn": *mapping.EventSourceArn,
   131  					"function_name":    *mapping.FunctionArn,
   132  				},
   133  				lambdaAllowEmptyValues,
   134  				map[string]interface{}{},
   135  			))
   136  		}
   137  	}
   138  	return nil
   139  }
   140  
   141  func (g *LambdaGenerator) addLayerVersions(svc *lambda.Client) error {
   142  	pl := lambda.NewListLayersPaginator(svc, &lambda.ListLayersInput{})
   143  	for pl.HasMorePages() {
   144  		plage, err := pl.NextPage(context.TODO())
   145  		if err != nil {
   146  			return err
   147  		}
   148  		for _, layer := range plage.Layers {
   149  			pv := lambda.NewListLayerVersionsPaginator(svc, &lambda.ListLayerVersionsInput{
   150  				LayerName: layer.LayerName,
   151  			})
   152  			for pv.HasMorePages() {
   153  				pvage, err := pv.NextPage(context.TODO())
   154  				if err != nil {
   155  					return err
   156  				}
   157  				for _, layerVersion := range pvage.LayerVersions {
   158  					g.Resources = append(g.Resources, terraformutils.NewSimpleResource(
   159  						*layerVersion.LayerVersionArn,
   160  						*layerVersion.LayerVersionArn,
   161  						"aws_lambda_layer_version",
   162  						"aws",
   163  						lambdaAllowEmptyValues,
   164  					))
   165  				}
   166  			}
   167  		}
   168  	}
   169  	return nil
   170  }