public static NeptuneClusterMetadata createFromClusterId()

in src/main/java/com/amazonaws/services/neptune/cluster/NeptuneClusterMetadata.java [96:220]
99 lines of code
9 McCabe index (conditional complexity)

    public static NeptuneClusterMetadata createFromClusterId(String clusterId, Supplier<NeptuneClient> amazonNeptuneClientSupplier) {

        NeptuneClient neptune = amazonNeptuneClientSupplier.get();

        DescribeDbClustersResponse describeDbClustersResponse = neptune
                .describeDBClusters(DescribeDbClustersRequest.builder().dbClusterIdentifier(clusterId).build());

        if (describeDbClustersResponse.dbClusters().isEmpty()) {
            throw new IllegalArgumentException(String.format("Unable to find cluster %s", clusterId));
        }

        DBCluster dbCluster = describeDbClustersResponse.dbClusters().get(0);

        List<Tag> tags = neptune.listTagsForResource(
                ListTagsForResourceRequest.builder().resourceName(dbCluster.dbClusterArn()).build()
        ).tagList();

        Map<String, String> clusterTags = new HashMap<>();
        tags.forEach(t -> clusterTags.put(t.key(), t.value()));

        boolean isIAMDatabaseAuthenticationEnabled = dbCluster.iamDatabaseAuthenticationEnabled();
        Integer port = dbCluster.port();
        String dbClusterParameterGroup = dbCluster.dbClusterParameterGroup();
        String engineVersion = dbCluster.engineVersion();

        String dbParameterGroupFamily;

        try {
            DescribeDbClusterParameterGroupsResponse describeDbClusterParameterGroupsResponse = neptune.describeDBClusterParameterGroups(
                    DescribeDbClusterParameterGroupsRequest.builder()
                            .dbClusterParameterGroupName(dbClusterParameterGroup)
                            .build()
            );

            Optional<DBClusterParameterGroup> parameterGroup = describeDbClusterParameterGroupsResponse
                    .dbClusterParameterGroups().stream().findFirst();

            dbParameterGroupFamily = parameterGroup.isPresent() ?
                    parameterGroup.get().dbParameterGroupFamily() :
                    "neptune1";

        } catch (NeptuneException e) {

            // Older deployments of Neptune Export service may not have requisite permissions to
            // describe cluster parameter group, so we'll try and guess the group family.


            if (StringUtils.isNotEmpty(engineVersion) && engineVersion.contains(".")) {
                int v = Integer.parseInt(engineVersion.split("\\.")[1]);
                if (v == 3) {
                    dbParameterGroupFamily = "neptune1.3";
                } else {
                    dbParameterGroupFamily = v > 1 ? "neptune1.2" : "neptune1";
                }
            } else {
                dbParameterGroupFamily = "neptune1";
            }
        }

        DescribeDbClusterParametersResponse describeDbClusterParametersResponse = neptune.describeDBClusterParameters(
                DescribeDbClusterParametersRequest.builder()
                        .dbClusterParameterGroupName(dbClusterParameterGroup)
                        .build()
        );
        Optional<Parameter> neptuneStreamsParameter = describeDbClusterParametersResponse.parameters().stream()
                .filter(parameter -> parameter.parameterName().equals("neptune_streams"))
                .findFirst();
        boolean isStreamEnabled = neptuneStreamsParameter.isPresent() &&
                neptuneStreamsParameter.get().parameterValue().equals("1");

        String dbSubnetGroup = dbCluster.dbSubnetGroup();
        List<VpcSecurityGroupMembership> vpcSecurityGroups = dbCluster.vpcSecurityGroups();
        List<String> vpcSecurityGroupIds = vpcSecurityGroups.stream()
                .map(VpcSecurityGroupMembership::vpcSecurityGroupId)
                .collect(Collectors.toList());

        List<DBClusterMember> dbClusterMembers = dbCluster.dbClusterMembers();
        Optional<DBClusterMember> clusterWriter = dbClusterMembers.stream()
                .filter(DBClusterMember::isClusterWriter)
                .findFirst();

        String primary = clusterWriter.map(DBClusterMember::dbInstanceIdentifier).orElse("");
        List<String> replicas = dbClusterMembers.stream()
                .filter(dbClusterMember -> !dbClusterMember.isClusterWriter())
                .map(DBClusterMember::dbInstanceIdentifier)
                .collect(Collectors.toList());

        DescribeDbInstancesRequest describeDBInstancesRequest = DescribeDbInstancesRequest.builder()
                .filters(Collections.singletonList(
                        Filter.builder()
                                .name("db-cluster-id")
                                .values(dbCluster.dbClusterIdentifier())
                                .build()
                )).build();

        DescribeDbInstancesResponse describeDbInstancesResponse = neptune
                .describeDBInstances(describeDBInstancesRequest);

        Map<String, NeptuneInstanceMetadata> instanceTypes = new HashMap<>();
        describeDbInstancesResponse.dbInstances()
                .forEach(c -> instanceTypes.put(
                        c.dbInstanceIdentifier(),
                        new NeptuneInstanceMetadata(
                                c.dbInstanceClass(),
                                c.dbParameterGroups().get(0).dbParameterGroupName(),
                                c.endpoint())
                ));

        neptune.close();

        return new NeptuneClusterMetadata(clusterId,
                port,
                engineVersion,
                dbClusterParameterGroup,
                dbParameterGroupFamily,
                isIAMDatabaseAuthenticationEnabled,
                isStreamEnabled,
                dbSubnetGroup,
                vpcSecurityGroupIds,
                primary,
                replicas,
                instanceTypes,
                clusterTags,
                amazonNeptuneClientSupplier);
    }