public async Task <Simulate> Run(SimulateParams simulateParams) { using (var client = new AmazonLambdaClient(RegionEndpoint.USEast2)) { var apirequest = new APIGatewayProxyRequest() { QueryStringParameters = new Dictionary <string, string>() }; foreach (PropertyInfo param in simulateParams.GetType().GetProperties()) { apirequest.QueryStringParameters.Add(param.Name, param.GetValue(simulateParams).ToString()); } var request = new InvokeRequest { FunctionName = "simulate", Payload = JsonConvert.SerializeObject(apirequest) }; var response = await client.InvokeAsync(request); string result; using (var sr = new StreamReader(response.Payload)) { result = sr.ReadToEnd(); SimulateHttpResponse httpResponse = JsonConvert.DeserializeObject <SimulateHttpResponse>(result); Simulate simulation = JsonConvert.DeserializeObject <Simulate>(httpResponse.Body); return(simulation); } } }
public async Task TestAllHandlersAsync() { // run all test cases in one test to ensure they run serially using (var lambdaClient = new AmazonLambdaClient(TestRegion)) using (var s3Client = new AmazonS3Client(TestRegion)) using (var iamClient = new AmazonIdentityManagementServiceClient(TestRegion)) { var roleAlreadyExisted = false; try { roleAlreadyExisted = await PrepareTestResources(s3Client, lambdaClient, iamClient); await RunTestSuccessAsync(lambdaClient, "ToUpperAsync", "message", "ToUpperAsync-MESSAGE"); await RunTestSuccessAsync(lambdaClient, "PingAsync", "ping", "PingAsync-pong"); await RunTestSuccessAsync(lambdaClient, "HttpsWorksAsync", "", "HttpsWorksAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "CertificateCallbackWorksAsync", "", "CertificateCallbackWorksAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "NetworkingProtocolsAsync", "", "NetworkingProtocolsAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "HandlerEnvVarAsync", "", "HandlerEnvVarAsync-HandlerEnvVarAsync"); await RunTestExceptionAsync(lambdaClient, "AggregateExceptionUnwrappedAsync", "", "Exception", "Exception thrown from an async handler."); await RunTestExceptionAsync(lambdaClient, "AggregateExceptionUnwrapped", "", "Exception", "Exception thrown from a synchronous handler."); await RunTestExceptionAsync(lambdaClient, "AggregateExceptionNotUnwrappedAsync", "", "AggregateException", "AggregateException thrown from an async handler."); await RunTestExceptionAsync(lambdaClient, "AggregateExceptionNotUnwrapped", "", "AggregateException", "AggregateException thrown from a synchronous handler."); await RunTestExceptionAsync(lambdaClient, "TooLargeResponseBodyAsync", "", "Function.ResponseSizeTooLarge", "Response payload size (7340060 bytes) exceeded maximum allowed payload size (6291556 bytes)."); await RunTestSuccessAsync(lambdaClient, "LambdaEnvironmentAsync", "", "LambdaEnvironmentAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "LambdaContextBasicAsync", "", "LambdaContextBasicAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "GetPidDllImportAsync", "", "GetPidDllImportAsync-SUCCESS"); await RunTestSuccessAsync(lambdaClient, "GetTimezoneNameAsync", "", "GetTimezoneNameAsync-UTC"); } finally { await CleanUpTestResources(s3Client, lambdaClient, iamClient, roleAlreadyExisted); } } }
private async Task NotifySubscribers(Subscription[] subscribers, Event @event) { using (var client = new AmazonLambdaClient()) { foreach (var subscriber in subscribers) { var request = new InvokeRequest { FunctionName = notifierFunctionResolver.GetNotifierFunction(), Payload = JsonConvert.SerializeObject(new LambdaInvocationPayload() { CompressedEvent = JsonConvert.SerializeObject(@event).ToCompressedBase64String(), Subscription = subscriber }), InvocationType = InvocationType.Event }; Console.WriteLine($"NotifySubscriber MessageId: {@event.Message.Header.MessageId} Subscriber: {subscriber.Type}:{subscriber.Endpoint}"); var response = await client.InvokeAsync(request); Console.WriteLine($"NotifySubscriberResponse MessageId: {@event.Message.Header.MessageId} Subscriber: {subscriber.Type}:{subscriber.Endpoint} Response Code: {response.StatusCode}"); if (response.StatusCode > 299) { Console.WriteLine($"MessageId: {@event.Message.Header.MessageId} Subscriber: {subscriber.Type}:{subscriber.Endpoint} Error: {response}"); } } } }
public InvokeResponse Invoke(string functionName, string path, string data) { JObject pathParams; var template_name = Path.Combine(System.Environment.CurrentDirectory, "WhooshRequestTemplate.json"); var fileData = File.ReadAllText(template_name); JObject payLoad = JObject.Parse(fileData); payLoad.Add("path", path); pathParams = (JObject)payLoad["pathParameters"]; pathParams.Add("key", data); var region_name = config.AwsRegionName; var env_id = "v8"; // var env_id = config.AwsNamespace; AmazonLambdaClient client = new AmazonLambdaClient(RegionEndpoint.GetBySystemName(region_name)); InvokeRequest request = new InvokeRequest() { FunctionName = $"PY-{env_id}", Payload = payLoad.ToString(), }; var response = client.InvokeAsync(request).GetAwaiter().GetResult(); return(response); }
public async void ExecuteLambda() { Debug.Log("ExecuteLambda"); AmazonLambdaClient amazonLambdaClient = new AmazonLambdaClient(_authenticationManager.GetCredentials(), AuthenticationManager.Region); InvokeRequest invokeRequest = new InvokeRequest { FunctionName = _lambdaFunctionName, InvocationType = InvocationType.RequestResponse }; InvokeResponse response = await amazonLambdaClient.InvokeAsync(invokeRequest); Debug.Log("Response statusCode: " + response.StatusCode); if (response.StatusCode == 200) { Debug.Log("Successful lambda call"); // demonstrate we can get the users ID for use in our game string userId = _authenticationManager.GetUsersId(); Debug.Log("UserId in LambdaManager: " + userId); } }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonLambdaConfig config = new AmazonLambdaConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonLambdaClient client = new AmazonLambdaClient(creds, config); ListFunctionsResponse resp = new ListFunctionsResponse(); do { ListFunctionsRequest req = new ListFunctionsRequest { Marker = resp.NextMarker , MaxItems = maxItems }; resp = client.ListFunctions(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.Functions) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextMarker)); }
private static async Task <List <FunctionConfiguration> > GetLambdaVersions(FunctionVersion functionVersion, AWSEnvironment environment) { var versionNumber = functionVersion != null ? Constants.LambdaAll : Constants.LambdaLastVersion; Console.WriteLine($"Reading lambda function versions: {versionNumber}"); var result = new List <FunctionConfiguration>(); var awsConfiguration = new AmazonLambdaConfig() { RegionEndpoint = RegionEndpoint.GetBySystemName(environment.Region) }; var awsCredentials = new BasicAWSCredentials(environment.AccessKey, environment.SecretKey); string marker = null; using (var awsClient = new AmazonLambdaClient(awsCredentials, awsConfiguration)) { do { var response = await awsClient.ListFunctionsAsync(new ListFunctionsRequest { Marker = marker, FunctionVersion = functionVersion }); //marker =Task<List<ListFunctionsRequest>> response.Result.NextMarker; marker = response.NextMarker; result.AddRange(response.Functions.Where(x => x.FunctionName.StartsWith($"{environment.Name.ToString()}"))); } while (!string.IsNullOrEmpty(marker)); return(result); } }
public async Task <String> SetPermission(AmazonLambdaClient lambda, String rulearn, String rulename) { //var RemovePermissionRequest = new RemovePermissionRequest //{ // FunctionName = "Ec2StartStop", // StatementId = rulename //}; try { var AddPermissionRequest = new AddPermissionRequest { Action = "lambda:InvokeFunction", FunctionName = "Ec2StartStop", Principal = "events.amazonaws.com", SourceArn = rulearn, StatementId = rulename }; var AddPermissionResponse = await lambda.AddPermissionAsync(AddPermissionRequest); return("sucessfully created permission"); } catch (Exception e) { return("permission already exists"); } }
public void TestLambdaInvokeSubsegmentContainsFunctionNameForAWSSDKHandler() { String temp_path = @"JSONs\AWSRequestInfoWithLambda.json"; //registering manifest file with Lambda AWSSDKHandler.RegisterXRayManifest(temp_path); var lambda = new AmazonLambdaClient(new AnonymousAWSCredentials(), RegionEndpoint.USEast1); CustomResponses.SetResponse(lambda, null, null, true); AWSXRayRecorder.Instance.BeginSegment("lambda", TraceId); #if NET45 lambda.Invoke(new InvokeRequest { FunctionName = "testFunction" }); #else lambda.InvokeAsync(new InvokeRequest { FunctionName = "testFunction" }).Wait(); #endif var segment = TraceContext.GetEntity(); AWSXRayRecorder.Instance.EndSegment(); Assert.AreEqual("Invoke", segment.Subsegments[0].Aws["operation"]); Assert.AreEqual("testFunction", segment.Subsegments[0].Aws["function_name"]); }
public async Task TestThreadingLogging() { // run all test cases in one test to ensure they run serially using (var lambdaClient = new AmazonLambdaClient(TestRegion)) using (var s3Client = new AmazonS3Client(TestRegion)) using (var iamClient = new AmazonIdentityManagementServiceClient(TestRegion)) { var roleAlreadyExisted = false; try { roleAlreadyExisted = await PrepareTestResources(s3Client, lambdaClient, iamClient); await InvokeLoggerTestController(lambdaClient); } catch (NoDeploymentPackageFoundException) { #if DEBUG // The CodePipeline for this project doesn't currently build the deployment in the stage that runs // this test. For now ignore this test in release mode if the deployment package can't be found. throw; #endif } finally { await CleanUpTestResources(s3Client, lambdaClient, iamClient, roleAlreadyExisted); } } }
private async Task <bool> InvokeFunction(string function, dynamic payload) { AmazonLambdaClient lambda; if (Debugger.IsAttached) { lambda = new AmazonLambdaClient(new BasicAWSCredentials(_configuration["AWS:AccessKey"], _configuration["AWS:SecretKey"]), RegionEndpoint.USEast1); } else { lambda = new AmazonLambdaClient(RegionEndpoint.USEast1); } var request = new InvokeRequest { FunctionName = function, Payload = JsonConvert.SerializeObject(new APIGatewayProxyRequest() { Body = JsonConvert.SerializeObject(payload) }) }; var response = await lambda.InvokeAsync(request); using var sr = new StreamReader(response.Payload); var content = await sr.ReadToEndAsync(); var result = JsonConvert.DeserializeObject <APIGatewayProxyRequest>(content); var fbResponse = JsonConvert.DeserializeObject <Response>(result.Body); return(fbResponse.Content.Equals(true)); }
public static string UpdateLambdaFunction(string functionName, string javaScript) { var ms = new MemoryStream(); File.WriteAllText(Properties.Settings.Default.RuleFilePath, javaScript); using (var zipArchive = new ZipArchive(ms, ZipArchiveMode.Create, true)) { zipArchive.CreateEntryFromFile(Properties.Settings.Default.IndexFilePath, Path.GetFileName(Properties.Settings.Default.IndexFilePath), CompressionLevel.Fastest); zipArchive.CreateEntryFromFile(Properties.Settings.Default.RuleFilePath, Path.GetFileName(Properties.Settings.Default.RuleFilePath), CompressionLevel.Fastest); } string responseText; try { var client = new AmazonLambdaClient(Properties.Settings.Default.AwsAccessKeyId, Properties.Settings.Default.AwsSecretKey, Amazon.RegionEndpoint.USEast1); var response = client.UpdateFunctionCode(new UpdateFunctionCodeRequest { FunctionName = functionName, Publish = false, ZipFile = ms }); responseText = response.ToString(); } catch (Exception ex) { responseText = ex.ToString(); } return(responseText); }
public void PrintPosts() { using (AmazonLambdaClient client = new AmazonLambdaClient()) { GetPostsRequest postsRequest = new GetPostsRequest() { SortBy = "timestamp", SortOrder = "descending", PostsToGet = postsToGet }; string payload = GetJson(typeof(GetPostsRequest), postsRequest); InvokeRequest iRequest = new InvokeRequest() { FunctionName = "GetPosts", Payload = payload }; InvokeResponse response = client.Invoke(iRequest); var sr = new StreamReader(response.Payload); string result = sr.ReadToEnd(); if (result.Contains("\"result\":\"failure\"")) { GetPostsFail(result); return; } download = ProcessPostDataJson(result); IList <GridItem> items = download.Values; dataGrid.ItemsSource = items; dataGrid.ColumnWidth = DataGridLength.SizeToCells; int itemCount = dataGrid.Items.Count; dataGrid.ScrollIntoView(dataGrid.Items[itemCount - 1]); } }
public async UniTask <ConnectionConfig> GetConnectionConfig(string roomName, string playerId) { RegionEndpoint regionEndpoint = RegionEndpoint.GetBySystemName(_Config.Region); CognitoAWSCredentials credentials = new CognitoAWSCredentials(_Config.IdentityPoolId, regionEndpoint); AmazonLambdaClient lambdaClient = new AmazonLambdaClient(credentials, regionEndpoint); string jsonStr = JsonUtility.ToJson(new ConnectionConfigRequest(roomName, playerId)); var response = await InvokeLambdaFunctionAsync(lambdaClient, _Config.LambdaFunctionName, InvocationType.RequestResponse, jsonStr); if (response.FunctionError == null) { if (response.StatusCode == 200) { var payload = Encoding.ASCII.GetString(response.Payload.ToArray()) + "\n"; var session = JsonUtility.FromJson <ConnectionConfigResponse>(payload); if (session == null) { Debug.LogError($"[LambdaClient] Error in Lambda: {payload}"); } else { return(new ConnectionConfig(session.IpAddress, session.Port, session.SystemUserId)); } } } Debug.LogError(response.FunctionError); return(ConnectionConfig.GetDefault()); }
public async Task <object> FunctionHandler(ILambdaContext context) { try { using (AmazonLambdaClient client = new AmazonLambdaClient(RegionEndpoint.APSoutheast1)) { var request = new Amazon.Lambda.Model.InvokeRequest { FunctionName = "test_call_rest_api", Payload = "" }; var response = await client.InvokeAsync(request); using (var sr = new StreamReader(response.Payload)) { var unit = JsonConvert.DeserializeObject(sr.ReadToEndAsync().Result, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); return(unit); } } } catch (Exception ex) { return(ex.Message); } }
// ADD TO MIDDLE public async Task <bool> IsReferencePhotoValid(string filePath) { Object emotResult = new ArrayList(); // Uploading file to S3 await uploadReferencePhoto(filePath); // Calling our Lambda function AmazonLambdaClient amazonLambdaClient = new AmazonLambdaClient(accessKey, privateKey, Amazon.RegionEndpoint.EUWest2); InvokeRequest ir = new InvokeRequest(); ir.InvocationType = InvocationType.RequestResponse; ir.FunctionName = "IsReferencePhotoValid"; // Selecting which file from S3 should our function use ir.Payload = "\"" + "referencePhoto.jpg" + "\""; // Getting the result var resultAWS = await amazonLambdaClient.InvokeAsync(ir); // Picking up the result value string response = Encoding.ASCII.GetString(resultAWS.Payload.ToArray()); response = response.Replace("\"", ""); bool result = bool.Parse(response); if (result == false) { throw new InvalidReferencePictureException("test"); } return(bool.Parse(response)); }
public static async Task <string> InvokeAWSLambda(string functionName, string payLoad, RegionEndpoint regionEndpoint) { try { if (!String.IsNullOrEmpty(functionName) && !String.IsNullOrEmpty(payLoad)) { var newPayload = new RoutingLambdaRequestModel() { body = payLoad }; var lambdaClient = new AmazonLambdaClient(IdentifierEnvironmentConstants.IdentifierConfigurations.RoutingLambdaCredentials.AccessKey, IdentifierEnvironmentConstants.IdentifierConfigurations.RoutingLambdaCredentials.Secret, regionEndpoint); var response = await lambdaClient.InvokeAsync(new InvokeRequest { FunctionName = functionName, InvocationType = InvocationType.RequestResponse, LogType = LogType.None, Payload = JsonConvert.SerializeObject(newPayload) }); using (var reader = response.Payload) { return(new StreamReader(reader).ReadToEnd()); } } } catch (Exception ex) { throw ex; } return(null); }
// ADD TO MIDDLE public async Task <string> WhatEmot(string filePath, string fileName) { Object emotResult = new ArrayList(); // Uploading file to S3 await UploadToS3(filePath, fileName); // Calling our Lambda function AmazonLambdaClient amazonLambdaClient = new AmazonLambdaClient(accessKey, privateKey, Amazon.RegionEndpoint.EUWest2); InvokeRequest ir = new InvokeRequest(); ir.InvocationType = InvocationType.RequestResponse; ir.FunctionName = "MyAWS"; // Selecting which file from S3 should our function use ir.Payload = "\"" + fileName + "\""; // Getting the result var result = await amazonLambdaClient.InvokeAsync(ir); // Picking up the result value string response = Encoding.ASCII.GetString(result.Payload.ToArray()); return(response); }
private static async Task <bool> DeleteLambda(FunctionConfiguration lambda, AWSEnvironment environment) { try { var awsConfiguration = new AmazonLambdaConfig() { RegionEndpoint = RegionEndpoint.GetBySystemName(environment.Region) }; var awsCredentials = new BasicAWSCredentials(environment.AccessKey, environment.SecretKey); using (var awsClient = new AmazonLambdaClient(awsCredentials, awsConfiguration)) { var response = await awsClient.DeleteFunctionAsync(new DeleteFunctionRequest { FunctionName = lambda.FunctionName, Qualifier = lambda.Version //ARN }); Console.WriteLine($"Lamba {lambda.FunctionName} deleted."); return(response.HttpStatusCode == HttpStatusCode.NoContent); //204 }; } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.DarkRed; Console.WriteLine($"Error: {ex.Message}"); Console.ForegroundColor = ConsoleColor.White; } return(false); }
public static async Task DeleteJobAsync(ApiGatewayRequest request, McmaApiResponse response) { Logger.Debug(nameof(DeleteJobAsync)); Logger.Debug(request.ToMcmaJson().ToString()); var table = new DynamoDbTable(request.StageVariables["TableName"]); var jobId = request.StageVariables["PublicUrl"] + request.Path; var job = await table.GetAsync <Job>(jobId); if (job == null) { response.StatusCode = (int)HttpStatusCode.NotFound; response.StatusMessage = "No resource found on path '" + request.Path + "'."; return; } await table.DeleteAsync <Job>(jobId); // invoking worker lambda function that will delete the JobProcess created for this Job if (!string.IsNullOrEmpty(job.JobProcess)) { var lambdaClient = new AmazonLambdaClient(); var invokeRequest = new InvokeRequest { FunctionName = request.StageVariables["WorkerLambdaFunctionName"], InvocationType = "Event", LogType = "None", Payload = new { action = "deleteJobProcess", request = request, jobProcessId = job.JobProcess }.ToMcmaJson().ToString() }; await lambdaClient.InvokeAsync(invokeRequest); } }
void Awake() { UnityInitializer.AttachToGameObject(gameObject); credentials = new CognitoAWSCredentials("eu-west-2:793871cb-c8a9-45bf-b20d-97df75ddbce7", RegionEndpoint.EUWest2); lambda = new AmazonLambdaClient(credentials, RegionEndpoint.EUWest2); }
async static Task InvokeViaSdk(Stream fileStream) { var lambdaConfig = new AmazonLambdaConfig { ServiceURL = "http://localhost:4566" }; using var lambda = new AmazonLambdaClient(lambdaConfig); using var memoryStream = new MemoryStream(); fileStream.CopyTo(memoryStream); var getFunctionRequest = new GetFunctionRequest { FunctionName = "ConverterTronStack-ConverterTronLambda-V6ZBU97Z5XM0" }; var invokeRequest = new InvokeRequest { FunctionName = "ConverterTronStack-ConverterTronLambda-V6ZBU97Z5XM0", InvocationType = InvocationType.RequestResponse, PayloadStream = memoryStream }; var getThings = await lambda.GetFunctionAsync(getFunctionRequest); var response = await lambda.InvokeAsync(invokeRequest); }
static void Main(string[] args) { //Create a new AmazonLambdaClient AmazonLambdaClient client = new AmazonLambdaClient("awsaccessKeyID", "awsSecreteAccessKey", RegionEndpoint.USEast2); //Create new InvokeRequest with published function name. InvokeRequest invoke = new InvokeRequest { FunctionName = "MyNewFunction", InvocationType = InvocationType.RequestResponse, Payload = "\"Test\"" }; //Get the InvokeResponse from client InvokeRequest. InvokeResponse response = client.Invoke(invoke); //Read the response stream var stream = new StreamReader(response.Payload); JsonReader reader = new JsonTextReader(stream); var serilizer = new JsonSerializer(); var responseText = serilizer.Deserialize(reader); //Convert Base64String into PDF document byte[] bytes = Convert.FromBase64String(responseText.ToString()); FileStream fileStream = new FileStream("Sample.pdf", FileMode.Create); BinaryWriter writer = new BinaryWriter(fileStream); writer.Write(bytes, 0, bytes.Length); writer.Close(); System.Diagnostics.Process.Start("Sample.pdf"); }
public static async Task ProcessNotificationAsync(ApiGatewayRequest request, McmaApiResponse response) { var table = new DynamoDbTable(request.StageVariables["TableName"]); var jobAssignmentId = request.StageVariables["PublicUrl"] + "/job-assignments/" + request.PathVariables["id"]; var jobAssignment = await table.GetAsync <JobAssignment>(jobAssignmentId); if (jobAssignment == null) { response.StatusCode = (int)HttpStatusCode.NotFound; response.StatusMessage = "No resource found on path '" + request.Path + "'"; return; } var notification = request.JsonBody?.ToMcmaObject <Notification>(); if (notification == null) { response.StatusCode = (int)HttpStatusCode.BadRequest; response.StatusMessage = "Missing notification in request body"; return; } var lambdaClient = new AmazonLambdaClient(); var invokeRequest = new InvokeRequest { FunctionName = request.StageVariables["WorkerLambdaFunctionName"], InvocationType = "Event", LogType = "None", Payload = new { action = "ProcessNotification", request = request, jobAssignmentId = jobAssignmentId, notification = notification }.ToMcmaJson().ToString() }; await lambdaClient.InvokeAsync(invokeRequest); }
/// <summary> /// Clean up all test resources. /// Also cleans up any resources that might be left from previous failed/interrupted tests. /// </summary> /// <param name="s3Client"></param> /// <param name="lambdaClient"></param> /// <returns></returns> private async Task CleanUpTestResources(AmazonS3Client s3Client, AmazonLambdaClient lambdaClient, AmazonIdentityManagementServiceClient iamClient, bool roleAlreadyExisted) { await DeleteFunctionIfExistsAsync(lambdaClient); var listBucketsResponse = await s3Client.ListBucketsAsync(); foreach (var bucket in listBucketsResponse.Buckets) { if (bucket.BucketName.StartsWith(TestBucketRoot)) { await DeleteDeploymentZipAndBucketAsync(s3Client, bucket.BucketName); } } if (!roleAlreadyExisted) { try { var deleteRoleRequest = new DeleteRoleRequest { RoleName = ExecutionRoleName }; await iamClient.DeleteRoleAsync(deleteRoleRequest); } catch (Exception) { // no problem - it's best effort } } }
public async Task Given_valid_payload_when_lambda_invoked_synchronously_then_should_return_expected_response() { // Given var client = new AmazonLambdaClient(); var sqsEvent = new SQSEvent { Records = new List <SQSEvent.SQSMessage> { new SQSEvent.SQSMessage { Body = "Hello Lambda!" } } }; var request = new InvokeRequest { FunctionName = "1-direct-invocation", // force sync lambda invocation InvocationType = InvocationType.RequestResponse, LogType = LogType.Tail, Payload = JsonSerializer.Serialize(sqsEvent) }; // When var result = await client.InvokeAsync(request); // Then Assert.Null(result.FunctionError); using var sr = new StreamReader(result.Payload); var response = await sr.ReadToEndAsync(); Assert.Equal("HELLO LAMBDA!", response.Replace("\"", "")); }
public override async Task <APIGatewayProxyResponse> FunctionHandlerAsync(APIGatewayProxyRequest request, ILambdaContext lambdaContext) { Console.WriteLine("In overridden FunctionHandlerAsync..."); if (request.Resource == "WarmingLambda") { int.TryParse(request.Body, out var concurrencyCount); if (concurrencyCount > 1) { Console.WriteLine($"Warming instance {concurrencyCount}."); var client = new AmazonLambdaClient(); await client.InvokeAsync(new Amazon.Lambda.Model.InvokeRequest { FunctionName = lambdaContext.FunctionName, InvocationType = InvocationType.RequestResponse, Payload = JsonConvert.SerializeObject(new APIGatewayProxyRequest { Resource = request.Resource, Body = (concurrencyCount - 1).ToString() }) }); } return(new APIGatewayProxyResponse { }); } return(await base.FunctionHandlerAsync(request, lambdaContext)); }
async Task ConfigureLambdaWithQueueAsync(string queueName) { string queueArn = null; AmazonSQSClient sqsClient = AwsFactory.CreateClient <AmazonSQSClient>(); GetQueueUrlRequest queueUrlReq = new GetQueueUrlRequest(); queueUrlReq.QueueName = queueName; GetQueueUrlResponse getQueueUrlResp = await sqsClient.GetQueueUrlAsync(queueUrlReq); GetQueueAttributesRequest queueAttribReq = new GetQueueAttributesRequest(); queueAttribReq.AttributeNames.Add(QueueAttributeName.QueueArn); queueAttribReq.QueueUrl = getQueueUrlResp.QueueUrl; var queueAttribResp = await sqsClient.GetQueueAttributesAsync(queueAttribReq); queueArn = queueAttribResp.QueueARN; AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>(); CreateEventSourceMappingRequest eventMappingReq = new CreateEventSourceMappingRequest(); eventMappingReq.FunctionName = "WebhookDispatcher"; eventMappingReq.BatchSize = 10; eventMappingReq.Enabled = true; eventMappingReq.EventSourceArn = queueArn; await lambdaClient.CreateEventSourceMappingAsync(eventMappingReq); }
private static LambdaWorkerExecutor CreateExecutor() { var lambda = new AmazonLambdaClient(); var functionName = Environment.GetEnvironmentVariable("WORKER_FUNCTION_NAME"); return(new LambdaWorkerExecutor(lambda, functionName)); }
internal static async Task <UpdateFunctionCodeResponse> UpdateFunctionCodeAsync ( this AmazonLambdaClient client, AppPackage package, ASPNetServerLessPublishAWSLambdaConfigSection lambdaConfig, CancellationToken cancellationToken = default(CancellationToken) ) { var response = (UpdateFunctionCodeResponse)null; using (var packageStream = new MemoryStream(package.PackageBytes)) { var updateCodeRequest = new UpdateFunctionCodeRequest() { FunctionName = lambdaConfig.FunctionName, ZipFile = packageStream }; response = await client.UpdateFunctionCodeAsync(updateCodeRequest, cancellationToken).ConfigureAwait(false); updateCodeRequest = null; } return(response); }