LAMBJ-83 Runner Method Configuration (#92)

Author: talenfisher

.github/releases/v0.6.0-beta2.md

@@ -1,3 +1,4 @@
 This release introduces the following:
 
-- You can now shrink package sizes by utilizing the new Lambdajection Layer!  For the time being, this is only available for those also using the Lambdajection Custom Runtime. Support for aws-hosted dotnetcore3.1 may be added in a future release.
+- You can now shrink package sizes by utilizing the new Lambdajection Layer!  For the time being, this is only available for those also using the Lambdajection Custom Runtime. Support for aws-hosted dotnetcore3.1 may be added in a future release.
+- The "Run" method name can now be customized using the RunnerMethod property in the Lambda Attribute.

README.md

@@ -290,6 +290,9 @@ So, going off the example above, the handler scheme would look like this:
 Your.Assembly.Name::Your.Namespace.YourLambda::Run
 ```
 
+You can customize the name of the "Run" method via the
+RunnerMethod property of `LambdaAttribute`.
+
 ### 4.9. Custom Runtimes
 
 Lambdajection can be used with custom runtimes starting in v0.5.0-beta2, that way you can use a newer version of .NET as soon as it comes out, even if it is not an LTS release.  

examples/CustomRuntime/CustomRuntime.csproj

@@ -11,8 +11,8 @@
         <PackageReference Include="Lambdajection.Runtime" Version="$(LambdajectionVersion)" />
         <PackageReference Include="Lambdajection.Layer" Version="$(LambdajectionVersion)" />
 
-        <!-- Ready to run compiler looks for AWSSDK.Core since Lambdajection.Core has references to it -->
-        <PackageReference Include="AWSSDK.Core" Version="3.5.1.2" />
+        <!-- If you don't use Lambdajection.Layer, the ready to run compiler will look for AWSSDK.Core since Lambdajection.Core has references to it -->
+        <!-- <PackageReference Include="AWSSDK.Core" Version="3.5.1.2" /> -->
     </ItemGroup>
 
 </Project>

src/Attributes/LambdaAttribute.cs

@@ -31,5 +31,15 @@ public LambdaAttribute(Type startup)
         /// <summary>Gets or sets the Config Factory to use for the Lambda.</summary>
         /// <value>The type of Config Factory to use for the Lambda.</value>
         public Type ConfigFactory { get; set; } = null!;
+
+        /// <summary>
+        /// Gets or sets the runner method name.
+        /// At compile-time, lambdajection generates a runner method, which is what gets invoked
+        /// by the runtime instead of your lambda's handle method.  The runner method is what sets
+        /// up dependency injection, configuration etc.  You can customize the runner method's name
+        /// with this property.
+        /// </summary>
+        /// <value>The name of the lambda's runner method.</value>
+        public string RunnerMethod { get; set; } = "Run";
     }
 }

src/Generator/GenerationContext.cs

@@ -30,6 +30,8 @@ public class GenerationContext
 
         public string StartupTypeDisplayName { get; set; }
 
+        public string RunnerMethodName { get; set; }
+
         public HashSet<string> Usings { get; } = new HashSet<string>();
 
         public GenerationSettings Settings { get; init; }

src/Generator/LambdaGenerator.cs

@@ -44,7 +44,7 @@ public ClassDeclarationSyntax Generate()
                 .WithBaseList(BaseList(Token(ColonToken), SeparatedList(typeConstraints)))
                 .AddModifiers(Token(PartialKeyword))
                 .AddMembers(
-                    GenerateRunMethod(),
+                    GenerateRunnerMethod(),
                     configurator);
 
             if (context.Settings.GenerateEntrypoint)
@@ -69,7 +69,7 @@ public ClassDeclarationSyntax Generate()
             return result;
         }
 
-        public MemberDeclarationSyntax GenerateRunMethod()
+        public MemberDeclarationSyntax GenerateRunnerMethod()
         {
             var modifiers = new SyntaxToken[]
             {
@@ -91,10 +91,11 @@ public MemberDeclarationSyntax GenerateRunMethod()
             });
 
             var parameterList = ParameterList(parameters);
-            var method = MethodDeclaration(ParseTypeName($"Task<{returnType}>"), "Run")
+            var body = Block(GenerateRunnerMethodBody());
+            var method = MethodDeclaration(ParseTypeName($"Task<{returnType}>"), context.RunnerMethodName)
                 .WithModifiers(TokenList(modifiers))
                 .WithParameterList(parameterList)
-                .WithBody(Block(GenerateRunMethodBody()));
+                .WithBody(body);
 
             var serializerName = GetSerializerName();
             var serializerNamespace = GetSerializerNamespace();
@@ -117,14 +118,15 @@ public MemberDeclarationSyntax GenerateRunMethod()
             return method;
         }
 
-        public IEnumerable<StatementSyntax> GenerateRunMethodBody()
+        public IEnumerable<StatementSyntax> GenerateRunnerMethodBody()
         {
             var configFactory = context.ConfigFactoryType?.Name ?? "LambdaConfigFactory";
             var configFactoryNamespace = context.ConfigFactoryType?.ContainingNamespace?.ToString() ?? "Lambdajection.Core";
             context.Usings.Add(configFactoryNamespace);
 
+            var inputParameterName = inputParameter!.Identifier.ValueText;
             yield return ParseStatement($"await using var host = new LambdaHost<{className}, {inputType}, {returnType}, {context.StartupTypeName}, LambdajectionConfigurator, {configFactory}>();");
-            yield return ParseStatement($"return await host.Run({inputParameter!.Identifier.ValueText}, context);");
+            yield return ParseStatement($"return await host.Run({inputParameterName}, context);");
         }
 
         public MemberDeclarationSyntax GenerateMainMethod()
@@ -134,7 +136,8 @@ public MemberDeclarationSyntax GenerateMainMethod()
 
             IEnumerable<StatementSyntax> GenerateBody()
             {
-                yield return ParseStatement($"using var wrapper = HandlerWrapper.GetHandlerWrapper((Func<{inputType}, ILambdaContext, Task<{returnType}>>)Run, new DefaultLambdaJsonSerializer());");
+                var runnerMethodName = context.RunnerMethodName;
+                yield return ParseStatement($"using var wrapper = HandlerWrapper.GetHandlerWrapper((Func<{inputType}, ILambdaContext, Task<{returnType}>>){runnerMethodName}, new DefaultLambdaJsonSerializer());");
                 yield return ParseStatement($"using var bootstrap = new LambdaBootstrap(wrapper);");
                 yield return ParseStatement($"await bootstrap.RunAsync();");
             }

src/Generator/UnitGenerator.cs

@@ -41,7 +41,7 @@ from node in tree.GetRoot().DescendantNodesAndSelf().OfType<ClassDeclarationSynt
                                   from attr in semanticModel.GetDeclaredSymbol(node)?.GetAttributes() ?? ImmutableArray.Create<AttributeData>()
                                   where attr.AttributeClass?.Name == nameof(LambdaAttribute)
 
-                                  let startupType = GetAttributeArgument(attr, "Startup")!
+                                  let startupType = GetAttributeArgument<INamedTypeSymbol>(attr, "Startup")!
                                   let generationContext = new GenerationContext
                                   {
                                       SourceGeneratorContext = context,
@@ -51,8 +51,9 @@ from attr in semanticModel.GetDeclaredSymbol(node)?.GetAttributes() ?? Immutable
                                       AttributeData = attr,
                                       CancellationToken = context.CancellationToken,
                                       StartupType = startupType,
-                                      SerializerType = GetAttributeArgument(attr, "Serializer"),
-                                      ConfigFactoryType = GetAttributeArgument(attr, "ConfigFactory"),
+                                      SerializerType = GetAttributeArgument<INamedTypeSymbol>(attr, "Serializer"),
+                                      ConfigFactoryType = GetAttributeArgument<INamedTypeSymbol>(attr, "ConfigFactory"),
+                                      RunnerMethodName = GetAttributeArgument<string>(attr, "RunnerMethod") ?? "Run",
                                       StartupTypeName = startupType.Name,
                                       StartupTypeDisplayName = startupType.ToDisplayString(),
                                       Settings = settings,
@@ -88,16 +89,16 @@ from attr in semanticModel.GetDeclaredSymbol(node)?.GetAttributes() ?? Immutable
             }
         }
 
-        public static INamedTypeSymbol? GetAttributeArgument(AttributeData attributeData, string argName)
+        public static T? GetAttributeArgument<T>(AttributeData attributeData, string argName)
         {
             if (argName == "Startup")
             {
-                return (INamedTypeSymbol?)attributeData.ConstructorArguments[0].Value;
+                return (T?)attributeData.ConstructorArguments[0].Value;
             }
 
             var query = from arg in attributeData.NamedArguments
                         where arg.Key == argName
-                        select (INamedTypeSymbol?)arg.Value.Value;
+                        select (T?)arg.Value.Value;
 
             return query.FirstOrDefault();
         }

tests/Compilation/Projects/CustomRunnerMethod/CustomRunnerMethod.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+    <RuntimeIdentifiers>linux-x64</RuntimeIdentifiers>
+    <SelfContained>false</SelfContained>
+    <IsPackable>false</IsPackable>
+    <NoWarn>CS8019</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Lambdajection" Version="$(LambdajectionVersion)" />
+
+    <!-- This is part of the test: does using a custom runtime work when the runner method name is customized? -->
+    <PackageReference Include="Lambdajection.Runtime" Version="$(LambdajectionVersion)" />
+  </ItemGroup>
+</Project>

tests/Compilation/Projects/CustomRunnerMethod/Handler.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+
+using Amazon.Lambda.Core;
+
+using Lambdajection.Attributes;
+using Lambdajection.Core;
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Lambdajection.CompilationTests.CustomRunnerMethod
+{
+    [Lambda(typeof(Startup), RunnerMethod = "Process")]
+    public partial class Handler
+    {
+        public Task<string> Handle(string request)
+        {
+            return Task.FromResult("Success");
+        }
+    }
+}
+

tests/Compilation/Projects/CustomRunnerMethod/Startup.cs

@@ -0,0 +1,19 @@
+using System.Threading.Tasks;
+
+using Amazon.Lambda.Core;
+
+using Lambdajection.Attributes;
+using Lambdajection.Core;
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Lambdajection.CompilationTests.CustomRunnerMethod
+{
+    public class Startup : ILambdaStartup
+    {
+        public void ConfigureServices(IServiceCollection services)
+        {
+        }
+    }
+}