コード例 #1
0
        private void ProcessPackageTypeProperty(ILambdaFunctionSerializable lambdaFunction, string propertiesPath, string relativeProjectUri)
        {
            _jsonWriter.SetToken($"{propertiesPath}.PackageType", lambdaFunction.PackageType.ToString());

            switch (lambdaFunction.PackageType)
            {
            case LambdaPackageType.Zip:
                _jsonWriter.SetToken($"{propertiesPath}.CodeUri", relativeProjectUri);
                _jsonWriter.SetToken($"{propertiesPath}.Handler", lambdaFunction.Handler);
                _jsonWriter.RemoveToken($"{propertiesPath}.ImageUri");
                _jsonWriter.RemoveToken($"{propertiesPath}.ImageConfig");
                break;

            case LambdaPackageType.Image:
                _jsonWriter.SetToken($"{propertiesPath}.ImageUri", relativeProjectUri);
                _jsonWriter.SetToken($"{propertiesPath}.ImageConfig.Command", new JArray(lambdaFunction.Handler));
                _jsonWriter.RemoveToken($"{propertiesPath}.Handler");
                _jsonWriter.RemoveToken($"{propertiesPath}.CodeUri");
                _jsonWriter.RemoveToken($"{propertiesPath}.Runtime");
                break;

            default:
                throw new InvalidEnumArgumentException($"The {nameof(lambdaFunction.PackageType)} does not match any supported enums of type {nameof(LambdaPackageType)}");
            }
        }
コード例 #2
0
        private void ProcessLambdaFunctionAttributes(ILambdaFunctionSerializable lambdaFunction, string propertiesPath, string relativeProjectUri)
        {
            if (lambdaFunction.Timeout > 0)
            {
                _jsonWriter.SetToken($"{propertiesPath}.Timeout", lambdaFunction.Timeout);
            }

            if (lambdaFunction.MemorySize > 0)
            {
                _jsonWriter.SetToken($"{propertiesPath}.MemorySize", lambdaFunction.MemorySize);
            }

            if (!string.IsNullOrEmpty(lambdaFunction.Role))
            {
                _jsonWriter.SetToken($"{propertiesPath}.Role", GetValueOrRef(lambdaFunction.Role));
                _jsonWriter.RemoveToken($"{propertiesPath}.Policies");
            }

            if (!string.IsNullOrEmpty(lambdaFunction.Policies))
            {
                var policyArray = lambdaFunction.Policies.Split(',').Select(x => GetValueOrRef(x.Trim()));
                _jsonWriter.SetToken($"{propertiesPath}.Policies", new JArray(policyArray));
                _jsonWriter.RemoveToken($"{propertiesPath}.Role");
            }

            ProcessPackageTypeProperty(lambdaFunction, propertiesPath, relativeProjectUri);
        }
コード例 #3
0
        private string ProcessRestApiAttribute(ILambdaFunctionSerializable lambdaFunction, RestApiAttribute restApiAttribute)
        {
            var eventPath  = $"Resources.{lambdaFunction.Name}.Properties.Events";
            var methodName = restApiAttribute.Method.ToString();
            var methodPath = $"{eventPath}.Root{methodName}";

            _jsonWriter.SetToken($"{methodPath}.Type", "Api");
            _jsonWriter.SetToken($"{methodPath}.Properties.Path", restApiAttribute.Template);
            _jsonWriter.SetToken($"{methodPath}.Properties.Method", methodName.ToUpper());

            return($"Root{methodName}");
        }
コード例 #4
0
        private void ProcessLambdaFunction(ILambdaFunctionSerializable lambdaFunction, string relativeProjectUri)
        {
            var lambdaFunctionPath = $"Resources.{lambdaFunction.Name}";
            var propertiesPath     = $"{lambdaFunctionPath}.Properties";

            if (!_jsonWriter.Exists(lambdaFunctionPath))
            {
                ApplyLambdaFunctionDefaults(lambdaFunctionPath, propertiesPath);
            }

            ProcessLambdaFunctionAttributes(lambdaFunction, propertiesPath, relativeProjectUri);
            ProcessLambdaFunctionEventAttributes(lambdaFunction);
        }
コード例 #5
0
        private bool ShouldProcessLambdaFunction(ILambdaFunctionSerializable lambdaFunction)
        {
            var lambdaFunctionPath = $"Resources.{lambdaFunction.Name}";

            if (!_jsonWriter.Exists(lambdaFunctionPath))
            {
                return(true);
            }

            var creationTool = _jsonWriter.GetToken($"{lambdaFunctionPath}.Metadata.Tool", string.Empty);

            return(string.Equals(creationTool.ToObject <string>(), "Amazon.Lambda.Annotations", StringComparison.Ordinal));
        }
コード例 #6
0
        private string ProcessHttpApiAttribute(ILambdaFunctionSerializable lambdaFunction, HttpApiAttribute httpApiAttribute)
        {
            var eventPath  = $"Resources.{lambdaFunction.Name}.Properties.Events";
            var methodName = httpApiAttribute.Method.ToString();
            var methodPath = $"{eventPath}.Root{methodName}";
            var version    = httpApiAttribute.Version == HttpApiVersion.V1 ? "1.0" : "2.0";

            _jsonWriter.SetToken($"{methodPath}.Type", "HttpApi");
            _jsonWriter.SetToken($"{methodPath}.Properties.Path", httpApiAttribute.Template);
            _jsonWriter.SetToken($"{methodPath}.Properties.Method", methodName.ToUpper());
            _jsonWriter.SetToken($"{methodPath}.Properties.PayloadFormatVersion", version);

            return($"Root{methodName}");
        }
コード例 #7
0
        private void ProcessLambdaFunctionEventAttributes(ILambdaFunctionSerializable lambdaFunction)
        {
            var currentSyncedEvents = new List <string>();

            foreach (var attributeModel in lambdaFunction.Attributes)
            {
                string eventName;
                switch (attributeModel)
                {
                case AttributeModel <HttpApiAttribute> httpApiAttributeModel:
                    eventName = ProcessHttpApiAttribute(lambdaFunction, httpApiAttributeModel.Data);
                    currentSyncedEvents.Add(eventName);
                    break;

                case AttributeModel <RestApiAttribute> restApiAttributeModel:
                    eventName = ProcessRestApiAttribute(lambdaFunction, restApiAttributeModel.Data);
                    currentSyncedEvents.Add(eventName);
                    break;
                }
            }

            var eventsPath = $"Resources.{lambdaFunction.Name}.Properties.Events";
            var syncedEventsMetadataPath = $"Resources.{lambdaFunction.Name}.Metadata.SyncedEvents";

            if (_jsonWriter.GetToken(syncedEventsMetadataPath, new JArray()) is JArray previousSyncedEvents)
            {
                foreach (var previousEventName in previousSyncedEvents.Select(x => x.ToObject <string>()))
                {
                    if (!currentSyncedEvents.Contains(previousEventName))
                    {
                        _jsonWriter.RemoveToken($"{eventsPath}.{previousEventName}");
                    }
                }
            }

            if (currentSyncedEvents.Any())
            {
                _jsonWriter.SetToken(syncedEventsMetadataPath, new JArray(currentSyncedEvents));
            }
            else
            {
                _jsonWriter.RemoveToken(syncedEventsMetadataPath);
            }
        }