Function Invocation

/**
 * Invokes Lambda function synchronously or asynchronously
 * @param request Invocation parameters including function name, payload, and type
 * @return InvokeResult containing response payload, status, and logs
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function doesn't exist
 * @throws InvalidParameterValueException if parameters are invalid
 * @throws TooManyRequestsException if concurrent executions exceed limits
 * @throws EC2UnexpectedException if VPC configuration causes issues
 * @throws EC2ThrottledException if VPC operations are throttled
 * @throws EC2AccessDeniedException if VPC access is denied
 * @throws ENILimitReachedException if VPC ENI limit is reached
 * @throws SubnetIPAddressLimitReachedException if VPC subnet IP limit reached
 * @throws InvalidSubnetIDException if VPC subnet ID is invalid
 * @throws InvalidSecurityGroupIDException if VPC security group ID is invalid
 * @throws InvalidZipFileException if deployment package is invalid
 * @throws KMSDisabledException if KMS key is disabled
 * @throws KMSInvalidStateException if KMS key is in invalid state
 * @throws KMSAccessDeniedException if KMS access is denied
 * @throws KMSNotFoundException if KMS key not found
 * @throws InvalidRuntimeException if runtime is invalid
 * @throws ResourceConflictException if function is being modified
 * @throws ResourceNotReadyException if function is not ready
 * @throws SnapStartException if SnapStart configuration causes errors
 * @throws SnapStartTimeoutException if SnapStart times out
 * @throws SnapStartNotReadyException if SnapStart is not ready
 * @throws RecursiveInvocationException if function invokes itself recursively
 */
InvokeResult invoke(InvokeRequest request);

public class InvokeRequest {
    /** Function name, ARN, or qualified ARN (required) */
    private String functionName;
    /** Invocation type (optional, default: RequestResponse) */
    private InvocationType invocationType;
    /** Log type for response (optional, default: None) */
    private LogType logType;
    /** Client context for mobile apps (optional) */
    private String clientContext;
    /** JSON payload for function (optional) */
    private ByteBuffer payload;
    /** Function version or alias (optional, default: $LATEST) */
    private String qualifier;
    
    public InvokeRequest withFunctionName(String functionName) { ... }
    public InvokeRequest withInvocationType(InvocationType invocationType) { ... }
    public InvokeRequest withLogType(LogType logType) { ... }
    public InvokeRequest withClientContext(String clientContext) { ... }
    public InvokeRequest withPayload(ByteBuffer payload) { ... }
    public InvokeRequest withPayload(String payload) { ... }
    public InvokeRequest withQualifier(String qualifier) { ... }
}

public class InvokeResult {
    /** HTTP status code (200 for success) */
    private Integer statusCode;
    /** Function error type (null for success) */
    private String functionError;
    /** Base64-encoded execution logs (if LogType.Tail) */
    private String logResult;
    /** Response payload from function */
    private ByteBuffer payload;
    /** Function version executed */
    private String executedVersion;
    
    /** Get payload as string */
    public String getPayloadAsString() {
        return payload != null ? new String(payload.array()) : null;
    }
    
    /** Check if invocation was successful */
    public boolean isSuccessful() {
        return statusCode != null && statusCode == 200 && functionError == null;
    }
    
    // Standard getters
}

/** Invocation type enumeration */
public enum InvocationType {
    /** Synchronous invocation (default) - waits for response */
    RequestResponse,
    /** Asynchronous invocation - returns immediately */
    Event,
    /** Validation only - doesn't execute function */
    DryRun
}

/** Log type enumeration */
public enum LogType {
    /** No logs in response (default) */
    None,
    /** Include last 4KB of logs in response (base64 encoded) */
    Tail
}

/**
 * @deprecated Use invoke() with InvocationType.Event instead
 * Legacy asynchronous function invocation
 * @param request Async invocation parameters
 * @return InvokeAsyncResult with basic status information
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function doesn't exist
 * @throws InvalidRequestContentException if request content is invalid
 */
@Deprecated
InvokeAsyncResult invokeAsync(InvokeAsyncRequest request);

@Deprecated
public class InvokeAsyncRequest {
    /** Function name (required) */
    private String functionName;
    /** JSON payload (required) */
    private InputStream invokeArgs;
    
    public InvokeAsyncRequest withFunctionName(String functionName) { ... }
    public InvokeAsyncRequest withInvokeArgs(InputStream invokeArgs) { ... }
}

@Deprecated
public class InvokeAsyncResult {
    /** HTTP status code */
    private Integer status;
    
    public Integer getStatus() { return status; }
}

import com.amazonaws.services.lambda.*;
import com.amazonaws.services.lambda.model.*;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.ObjectMapper;

// Create client
AWSLambda lambdaClient = AWSLambdaClientBuilder.defaultClient();
ObjectMapper objectMapper = new ObjectMapper();

// Synchronous invocation with JSON payload
Map<String, Object> payload = new HashMap<>();
payload.put("name", "John");
payload.put("age", 30);
String payloadJson = objectMapper.writeValueAsString(payload);

InvokeRequest request = new InvokeRequest()
    .withFunctionName("my-function")
    .withInvocationType(InvocationType.RequestResponse)
    .withLogType(LogType.Tail)
    .withPayload(payloadJson);

InvokeResult result = lambdaClient.invoke(request);

if (result.isSuccessful()) {
    String response = result.getPayloadAsString();
    System.out.println("Function response: " + response);
    
    // Parse logs if requested
    if (result.getLogResult() != null) {
        String logs = new String(Base64.getDecoder().decode(result.getLogResult()));
        System.out.println("Function logs: " + logs);
    }
} else {
    System.err.println("Function error: " + result.getFunctionError());
    System.err.println("Status code: " + result.getStatusCode());
}

// Asynchronous invocation (fire and forget)
InvokeRequest asyncRequest = new InvokeRequest()
    .withFunctionName("my-async-function")
    .withInvocationType(InvocationType.Event)
    .withPayload("{\"message\": \"Hello, async world!\"}");

InvokeResult asyncResult = lambdaClient.invoke(asyncRequest);
System.out.println("Async invocation status: " + asyncResult.getStatusCode());

// Dry run validation
InvokeRequest dryRunRequest = new InvokeRequest()
    .withFunctionName("my-function")
    .withInvocationType(InvocationType.DryRun)
    .withPayload("{\"test\": true}");

InvokeResult dryRunResult = lambdaClient.invoke(dryRunRequest);
if (dryRunResult.getStatusCode() == 204) {
    System.out.println("Function validation successful");
} else {
    System.out.println("Function validation failed");
}

// Invoke specific version or alias
InvokeRequest versionRequest = new InvokeRequest()
    .withFunctionName("my-function")
    .withQualifier("v1") // or alias like "PROD"
    .withPayload("{\"version\": \"specific\"}");

InvokeResult versionResult = lambdaClient.invoke(versionRequest);
System.out.println("Executed version: " + versionResult.getExecutedVersion());

// Error handling example
try {
    InvokeRequest errorRequest = new InvokeRequest()
        .withFunctionName("non-existent-function")
        .withPayload("{}");
    
    InvokeResult errorResult = lambdaClient.invoke(errorRequest);
} catch (ResourceNotFoundException e) {
    System.err.println("Function not found: " + e.getMessage());
} catch (TooManyRequestsException e) {
    System.err.println("Too many concurrent executions: " + e.getMessage());
} catch (Exception e) {
    System.err.println("Invocation failed: " + e.getMessage());
}

// Working with binary payloads
byte[] binaryData = "Binary payload content".getBytes(StandardCharsets.UTF_8);
InvokeRequest binaryRequest = new InvokeRequest()
    .withFunctionName("binary-function")
    .withPayload(ByteBuffer.wrap(binaryData));

InvokeResult binaryResult = lambdaClient.invoke(binaryRequest);
byte[] responseBytes = binaryResult.getPayload().array();

// Asynchronous client example
AWSLambdaAsync asyncClient = AWSLambdaAsyncClientBuilder.defaultClient();

Future<InvokeResult> futureResult = asyncClient.invokeAsync(request, 
    new AsyncHandler<InvokeRequest, InvokeResult>() {
        @Override
        public void onError(Exception exception) {
            System.err.println("Async invocation failed: " + exception.getMessage());
        }
        
        @Override
        public void onSuccess(InvokeRequest request, InvokeResult result) {
            System.out.println("Async invocation completed: " + result.getPayloadAsString());
        }
    });

// Wait for async result if needed
try {
    InvokeResult asyncResponse = futureResult.get(30, TimeUnit.SECONDS);
    System.out.println("Async result: " + asyncResponse.getPayloadAsString());
} catch (TimeoutException e) {
    System.err.println("Async invocation timed out");
    futureResult.cancel(true);
}