2023-08-01 22:11:21 +00:00
|
|
|
const std = @import("std");
|
|
|
|
const builtin = @import("builtin");
|
2024-08-27 23:29:43 +00:00
|
|
|
const Package = @import("lambdabuild/Package.zig");
|
|
|
|
const Iam = @import("lambdabuild/Iam.zig");
|
|
|
|
const Deploy = @import("lambdabuild/Deploy.zig");
|
|
|
|
const Invoke = @import("lambdabuild/Invoke.zig");
|
2023-08-01 22:11:21 +00:00
|
|
|
|
|
|
|
fn fileExists(file_name: []const u8) bool {
|
|
|
|
const file = std.fs.openFileAbsolute(file_name, .{}) catch return false;
|
|
|
|
defer file.close();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
fn addArgs(allocator: std.mem.Allocator, original: []const u8, args: [][]const u8) ![]const u8 {
|
|
|
|
var rc = original;
|
|
|
|
for (args) |arg| {
|
|
|
|
rc = try std.mem.concat(allocator, u8, &.{ rc, " ", arg });
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2024-05-06 18:14:24 +00:00
|
|
|
/// lambdaBuildSteps will add four build steps to the build (if compiling
|
2023-08-01 22:11:21 +00:00
|
|
|
/// the code on a Linux host):
|
|
|
|
///
|
2024-05-06 18:14:24 +00:00
|
|
|
/// * awslambda_package: Packages the function for deployment to Lambda
|
|
|
|
/// (dependencies are the zip executable and a shell)
|
|
|
|
/// * awslambda_iam: Gets an IAM role for the Lambda function, and creates it if it does not exist
|
|
|
|
/// (dependencies are the AWS CLI, grep and a shell)
|
|
|
|
/// * awslambda_deploy: Deploys the lambda function to a live AWS environment
|
|
|
|
/// (dependencies are the AWS CLI, and a shell)
|
|
|
|
/// * awslambda_run: Runs the lambda function in a live AWS environment
|
|
|
|
/// (dependencies are the AWS CLI, and a shell)
|
2023-08-01 22:11:21 +00:00
|
|
|
///
|
2024-05-06 18:14:24 +00:00
|
|
|
/// awslambda_run depends on deploy
|
|
|
|
/// awslambda_deploy depends on iam and package
|
2023-08-01 22:11:21 +00:00
|
|
|
///
|
|
|
|
/// iam and package do not have any dependencies
|
2024-05-06 18:14:24 +00:00
|
|
|
pub fn configureBuild(b: *std.Build, exe: *std.Build.Step.Compile, function_name: []const u8) !void {
|
2023-08-01 22:11:21 +00:00
|
|
|
// The rest of this function is currently reliant on the use of Linux
|
|
|
|
// system being used to build the lambda function
|
|
|
|
//
|
|
|
|
// It is likely that much of this will work on other Unix-like OSs, but
|
|
|
|
// we will work this out later
|
|
|
|
//
|
|
|
|
// TODO: support other host OSs
|
|
|
|
if (builtin.os.tag != .linux) return;
|
|
|
|
|
2024-08-27 23:29:43 +00:00
|
|
|
@import("aws").aws.globalLogControl(.info, .warn, .info, false);
|
|
|
|
const package_step = Package.create(b, .{ .exe = exe });
|
|
|
|
|
|
|
|
const step = b.step("awslambda_package", "Package the function");
|
|
|
|
step.dependOn(&package_step.step);
|
|
|
|
package_step.step.dependOn(b.getInstallStep());
|
|
|
|
|
|
|
|
// Doing this will require that the aws dependency be added to the downstream
|
|
|
|
// build.zig.zon
|
|
|
|
// const lambdabuild = b.addExecutable(.{
|
|
|
|
// .name = "lambdabuild",
|
|
|
|
// .root_source_file = .{
|
|
|
|
// // we use cwd_relative here because we need to compile this relative
|
|
|
|
// // to whatever directory this file happens to be. That is likely
|
|
|
|
// // in a cache directory, not the base of the build.
|
|
|
|
// .cwd_relative = try std.fs.path.join(b.allocator, &[_][]const u8{
|
|
|
|
// std.fs.path.dirname(@src().file).?,
|
|
|
|
// "lambdabuild/src/main.zig",
|
|
|
|
// }),
|
|
|
|
// },
|
|
|
|
// .target = b.host,
|
|
|
|
// });
|
|
|
|
// const aws_dep = b.dependency("aws", .{
|
|
|
|
// .target = b.host,
|
|
|
|
// .optimize = lambdabuild.root_module.optimize orelse .Debug,
|
|
|
|
// });
|
|
|
|
// const aws_module = aws_dep.module("aws");
|
|
|
|
// lambdabuild.root_module.addImport("aws", aws_module);
|
|
|
|
//
|
2023-08-01 22:11:21 +00:00
|
|
|
|
2024-05-06 18:14:24 +00:00
|
|
|
const iam_role_name = b.option(
|
|
|
|
[]const u8,
|
|
|
|
"function-role",
|
|
|
|
"IAM role name for function (will create if it does not exist) [lambda_basic_execution]",
|
2024-08-27 23:29:43 +00:00
|
|
|
) orelse "lambda_basic_execution_blah2";
|
|
|
|
|
2024-05-06 18:14:24 +00:00
|
|
|
const iam_role_arn = b.option(
|
|
|
|
[]const u8,
|
|
|
|
"function-arn",
|
|
|
|
"Preexisting IAM role arn for function",
|
|
|
|
);
|
|
|
|
|
2024-08-27 23:29:43 +00:00
|
|
|
const iam = Iam.create(b, .{
|
|
|
|
.role_name = iam_role_name,
|
|
|
|
.role_arn = iam_role_arn,
|
|
|
|
});
|
2024-05-06 18:14:24 +00:00
|
|
|
const iam_step = b.step("awslambda_iam", "Create/Get IAM role for function");
|
2024-08-27 23:29:43 +00:00
|
|
|
iam_step.dependOn(&iam.step);
|
2024-05-06 18:14:24 +00:00
|
|
|
|
2024-08-28 16:47:01 +00:00
|
|
|
const region = try b.allocator.create(@import("lambdabuild/Region.zig"));
|
|
|
|
region.* = .{
|
2024-08-27 23:43:16 +00:00
|
|
|
.allocator = b.allocator,
|
|
|
|
.specified_region = b.option([]const u8, "region", "Region to use [default is autodetect from environment/config]"),
|
|
|
|
};
|
2024-05-06 18:14:24 +00:00
|
|
|
|
2024-08-27 23:29:43 +00:00
|
|
|
// Deployment
|
|
|
|
const deploy = Deploy.create(b, .{
|
|
|
|
.name = function_name,
|
|
|
|
.arch = exe.root_module.resolved_target.?.result.cpu.arch,
|
|
|
|
.iam_step = iam,
|
2024-08-28 22:15:19 +00:00
|
|
|
.package_step = package_step,
|
2024-08-28 16:47:01 +00:00
|
|
|
.region = region,
|
2023-08-01 22:11:21 +00:00
|
|
|
});
|
|
|
|
|
2024-08-27 23:29:43 +00:00
|
|
|
const deploy_step = b.step("awslambda_deploy", "Deploy the function");
|
|
|
|
deploy_step.dependOn(&deploy.step);
|
2023-08-01 22:11:21 +00:00
|
|
|
|
|
|
|
const payload = b.option([]const u8, "payload", "Lambda payload [{\"foo\":\"bar\", \"baz\": \"qux\"}]") orelse
|
|
|
|
\\ {"foo": "bar", "baz": "qux"}"
|
|
|
|
;
|
|
|
|
|
2024-08-27 23:29:43 +00:00
|
|
|
const invoke = Invoke.create(b, .{
|
|
|
|
.name = function_name,
|
|
|
|
.payload = payload,
|
2024-08-28 16:47:01 +00:00
|
|
|
.region = region,
|
2024-08-27 23:29:43 +00:00
|
|
|
});
|
|
|
|
invoke.step.dependOn(&deploy.step);
|
2024-05-06 18:14:24 +00:00
|
|
|
const run_step = b.step("awslambda_run", "Run the app in AWS lambda");
|
2024-08-27 23:29:43 +00:00
|
|
|
run_step.dependOn(&invoke.step);
|
|
|
|
}
|
|
|
|
|
|
|
|
// AWS_CONFIG_FILE (default is ~/.aws/config
|
|
|
|
// AWS_DEFAULT_REGION
|
|
|
|
fn findRegionFromSystem(allocator: std.mem.Allocator) ![]const u8 {
|
|
|
|
const env_map = try std.process.getEnvMap(allocator);
|
|
|
|
if (env_map.get("AWS_DEFAULT_REGION")) |r| return r;
|
|
|
|
const config_file_path = env_map.get("AWS_CONFIG_FILE") orelse
|
|
|
|
try std.fs.path.join(allocator, &[_][]const u8{
|
|
|
|
env_map.get("HOME") orelse env_map.get("USERPROFILE").?,
|
|
|
|
".aws",
|
|
|
|
"config",
|
|
|
|
});
|
|
|
|
const config_file = try std.fs.openFileAbsolute(config_file_path, .{});
|
|
|
|
defer config_file.close();
|
|
|
|
const config_bytes = try config_file.readToEndAlloc(allocator, 1024 * 1024);
|
|
|
|
const profile = env_map.get("AWS_PROFILE") orelse "default";
|
|
|
|
var line_iterator = std.mem.split(u8, config_bytes, "\n");
|
|
|
|
var in_profile = false;
|
|
|
|
while (line_iterator.next()) |line| {
|
|
|
|
const trimmed = std.mem.trim(u8, line, " \t\r");
|
|
|
|
if (trimmed.len == 0 or trimmed[0] == '#') continue;
|
|
|
|
if (!in_profile) {
|
|
|
|
if (trimmed[0] == '[' and trimmed[trimmed.len - 1] == ']') {
|
|
|
|
// this is a profile directive!
|
|
|
|
// std.debug.print("profile: {s}, in file: {s}\n", .{ profile, trimmed[1 .. trimmed.len - 1] });
|
|
|
|
if (std.mem.eql(u8, profile, trimmed[1 .. trimmed.len - 1])) {
|
|
|
|
in_profile = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue; // we're only looking for a profile at this point
|
|
|
|
}
|
|
|
|
// look for our region directive
|
|
|
|
if (trimmed[0] == '[' and trimmed[trimmed.len - 1] == ']')
|
|
|
|
return error.RegionNotFound; // we've hit another profile without getting our region
|
|
|
|
if (!std.mem.startsWith(u8, trimmed, "region")) continue;
|
|
|
|
var equalityiterator = std.mem.split(u8, trimmed, "=");
|
|
|
|
_ = equalityiterator.next() orelse return error.RegionNotFound;
|
|
|
|
const raw_val = equalityiterator.next() orelse return error.RegionNotFound;
|
|
|
|
return try allocator.dupe(u8, std.mem.trimLeft(u8, raw_val, " \t"));
|
|
|
|
}
|
|
|
|
return error.RegionNotFound;
|
2023-08-01 22:11:21 +00:00
|
|
|
}
|