public Object handleRequest()

in resources/custom-resources/clear-s3-bucket/src/main/java/com/amazon/aws/partners/saasfactory/ClearS3Bucket.java [54:150]
88 lines of code
11 McCabe index (conditional complexity)

    public Object handleRequest(Map<String, Object> input, Context context) {
        LambdaLogger logger = context.getLogger();

        try {
            ObjectMapper mapper = new ObjectMapper();
            logger.log(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(input));
            logger.log("\n");
        } catch (JsonProcessingException e) {
            logger.log("Could not log input\n");
        }

        final String requestType = (String) input.get("RequestType");
        Map<String, Object> resourceProperties = (Map<String, Object>) input.get("ResourceProperties");
        final String bucket = (String) resourceProperties.get("Bucket");

        ExecutorService service = Executors.newSingleThreadExecutor();
        ObjectNode responseData = JsonNodeFactory.instance.objectNode();
        try {
            if (requestType == null) {
                throw new RuntimeException();
            }
            Runnable r = () -> {
                if ("Create".equalsIgnoreCase(requestType) || "Update".equalsIgnoreCase(requestType)) {
                    logger.log("CREATE or UPDATE\n");
                    sendResponse(input, context, "SUCCESS", responseData);
                } else if ("Delete".equalsIgnoreCase(requestType)) {
                    logger.log("DELETE\n");

                    // The list of objects in the bucket to delete
                    List<ObjectIdentifier> toDelete = new ArrayList<>();

                    // Is the bucket versioned?
                    GetBucketVersioningResponse versioningResponse = s3.getBucketVersioning(request -> request.bucket(bucket));
                    if (BucketVersioningStatus.ENABLED.equals(versioningResponse.status())) {
                        logger.log("Bucket " + bucket + " is versioned (" + versioningResponse.status() + ")\n");
                        ListObjectVersionsResponse response;
                        do {
                            response = s3.listObjectVersions(builder -> builder.bucket(bucket));
                            response.versions()
                                    .stream()
                                    .map(version ->
                                        ObjectIdentifier.builder()
                                                .key(version.key())
                                                .versionId(version.versionId())
                                                .build()
                                    )
                                    .forEachOrdered(toDelete::add);
                        } while (response.isTruncated());
                    } else {
                        logger.log("Bucket " + bucket + " is not versioned (" + versioningResponse.status() + ")\n");
                        ListObjectsV2Response response;
                        do {
                            response = s3.listObjectsV2(request -> request.bucket(bucket));
                            response.contents()
                                    .stream()
                                    .map(obj ->
                                            ObjectIdentifier.builder()
                                                    .key(obj.key())
                                                    .build()
                                    )
                                    .forEachOrdered(toDelete::add);
                        } while (response.isTruncated());
                    }
                    if (!toDelete.isEmpty()) {
                        DeleteObjectsResponse deleteResponse = s3.deleteObjects(builder -> builder
                                .bucket(bucket)
                                .delete(Delete.builder().objects(toDelete).build())
                        );
                        logger.log("Cleaned up " + deleteResponse.deleted().size() + " objects in bucket " + bucket + "\n");
                    } else {
                        logger.log("Bucket " + bucket + " is empty. No objects to clean up.\n");
                    }
                    sendResponse(input, context, "SUCCESS", responseData);
                } else {
                    logger.log("FAILED unknown requestType " + requestType + "\n");
                    responseData.put("Reason", "Unknown RequestType " + requestType);
                    sendResponse(input, context, "FAILED", responseData);
                }
            };
            Future<?> f = service.submit(r);
            f.get(context.getRemainingTimeInMillis() - 1000, TimeUnit.MILLISECONDS);
        } catch (final TimeoutException | InterruptedException | ExecutionException e) {
            // Timed out
            logger.log("FAILED unexpected error or request timed out " + e.getMessage() + "\n");
            // Print entire stack trace
            final StringWriter sw = new StringWriter();
            final PrintWriter pw = new PrintWriter(sw, true);
            e.printStackTrace(pw);
            String stackTrace = sw.getBuffer().toString();
            logger.log(stackTrace + "\n");
            responseData.put("Reason", stackTrace);
            sendResponse(input, context, "FAILED", responseData);
        } finally {
            service.shutdown();
        }
        return null;
    }