public Pair createCredentials()

in controller/src/main/java/org/apache/airavata/mft/controller/RequestBuilder.java [103:280]
145 lines of code
16 McCabe index (conditional complexity)

    public Pair<StorageWrapper, SecretWrapper> createCredentials(String storageId, String secretId) {

        if (secretCache.containsKey(secretId) && storageCache.containsKey(storageId)) {
            return Pair.of(storageCache.get(storageId),secretCache.get(secretId));
        }

        StorageTypeResolveResponse resolve = storageServiceClient.common()
                .resolveStorageType(StorageTypeResolveRequest.newBuilder().setStorageId(storageId).buildPartial());
        
        StorageWrapper.Builder storageBuilder = StorageWrapper.newBuilder();
        SecretWrapper.Builder secretBuilder = SecretWrapper.newBuilder();
        
        switch (resolve.getStorageType()) {
            case S3:
                S3Storage s3Storage = storageCache.containsKey(storageId)? storageCache.get(storageId).getS3():
                        storageServiceClient
                                .s3()
                                .getS3Storage(S3StorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setS3(s3Storage);

                S3Secret s3Secret = storageCache.containsKey(secretId)? secretCache.get(secretId).getS3():
                        secretServiceClient
                        .s3()
                        .getS3Secret(S3SecretGetRequest.newBuilder().setSecretId(secretId).build());
                
                secretBuilder.setS3(s3Secret);
                break;

            case SCP:
                SCPStorage scpStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getScp():
                        storageServiceClient
                        .scp()
                        .getSCPStorage(SCPStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setScp(scpStorage);

                SCPSecret scpSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getScp():
                        secretServiceClient
                        .scp()
                        .getSCPSecret(SCPSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setScp(scpSecret);
                break;
            case LOCAL:
                LocalStorage localStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getLocal():
                        storageServiceClient
                        .local()
                        .getLocalStorage(LocalStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setLocal(localStorage);
                break;
            case FTP:
                FTPStorage ftpStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getFtp():
                        storageServiceClient
                        .ftp()
                        .getFTPStorage(FTPStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setFtp(ftpStorage);

                FTPSecret ftpSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getFtp():
                        secretServiceClient
                        .ftp()
                        .getFTPSecret(FTPSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setFtp(ftpSecret);
                break;
            case BOX:
                BoxStorage boxStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getBox():
                        storageServiceClient
                        .box()
                        .getBoxStorage(BoxStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setBox(boxStorage);

                BoxSecret boxSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getBox():
                        secretServiceClient
                        .box()
                        .getBoxSecret(BoxSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setBox(boxSecret);
                break;
            case DROPBOX:
                DropboxStorage dropboxStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getDropbox():
                        storageServiceClient
                        .dropbox()
                        .getDropboxStorage(DropboxStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setDropbox(dropboxStorage);

                DropboxSecret dropboxSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getDropbox():
                        secretServiceClient
                        .dropbox()
                        .getDropboxSecret(DropboxSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setDropbox(dropboxSecret);
                break;

            case GCS:
                GCSStorage gcsStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getGcs():
                        storageServiceClient
                        .gcs()
                        .getGCSStorage(GCSStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setGcs(gcsStorage);

                GCSSecret gcsSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getGcs():
                        secretServiceClient
                        .gcs()
                        .getGCSSecret(GCSSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setGcs(gcsSecret);
                break;

            case AZURE:
                AzureStorage azureStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getAzure():
                        storageServiceClient
                        .azure()
                        .getAzureStorage(AzureStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setAzure(azureStorage);

                AzureSecret azureSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getAzure():
                        secretServiceClient
                        .azure()
                        .getAzureSecret(AzureSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setAzure(azureSecret);
                break;

            case SWIFT:
                SwiftStorage swiftStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getSwift():
                        storageServiceClient
                        .swift()
                        .getSwiftStorage(SwiftStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setSwift(swiftStorage);

                SwiftSecret swiftSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getSwift():
                        secretServiceClient
                        .swift()
                        .getSwiftSecret(SwiftSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setSwift(swiftSecret);
                break;

            case ODATA:
                ODataStorage odataStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getOdata():
                        storageServiceClient
                        .odata()
                        .getODataStorage(ODataStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setOdata(odataStorage);

                ODataSecret odataSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getOdata():
                        secretServiceClient
                        .odata()
                        .getODataSecret(ODataSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setOdata(odataSecret);
                break;
            case HTTP:
                HTTPStorage httpStorage = storageCache.containsKey(storageId)? storageCache.get(storageId).getHttp():
                        storageServiceClient
                                .http()
                                .getHTTPStorage(HTTPStorageGetRequest.newBuilder().setStorageId(storageId).build());
                storageBuilder.setHttp(httpStorage);

                HTTPSecret httpSecret = storageCache.containsKey(secretId)? secretCache.get(secretId).getHttp():
                        secretServiceClient
                                .http()
                                .getHTTPSecret(HTTPSecretGetRequest.newBuilder().setSecretId(secretId).build());

                secretBuilder.setHttp(httpSecret);
                break;
                    
        }

        if (!storageCache.containsKey(storageId)) {
            storageCache.put(storageId, storageBuilder.build());
        }

        if (!secretCache.containsKey(secretId)) {
            secretCache.put(secretId, secretBuilder.build());
        }

        return Pair.of(storageBuilder.build(), secretBuilder.build());
    }