target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testEthnicityQuery() { String conceptId = "38003563"; SearchParameter ethParam = new SearchParameter() .conceptId(Long.parseLong(conceptId)) .domain(DomainType.PERSON.toString()) .type(CriteriaType.ETHNICITY.toString()) .group(false) .ancestorData(false) .standard(true); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem(new SearchGroupItem().addSearchParametersItem(ethParam)))); assertThat(resp) .isEqualTo( nonNestedQuery( QueryBuilders.termsQuery("ethnicity_concept_id", ImmutableList.of(conceptId)))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testDeceasedQuery() { SearchParameter deceasedParam = new SearchParameter() .domain(DomainType.PERSON.toString()) .type(CriteriaType.DECEASED.toString()) .standard(true) .ancestorData(false) .group(false); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem( new SearchGroupItem().addSearchParametersItem(deceasedParam)))); assertThat(resp).isEqualTo(nonNestedQuery(QueryBuilders.termQuery("is_deceased", true))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testPregnancyQuery() { String conceptId = "903120"; String operand = "12345"; Attribute attr = new Attribute() .name(AttrName.CAT) .operator(Operator.IN) .operands(ImmutableList.of(operand)); SearchParameter pregParam = new SearchParameter() .conceptId(Long.parseLong(conceptId)) .domain(DomainType.PHYSICAL_MEASUREMENT.toString()) .type(CriteriaType.PPI.toString()) .group(false) .ancestorData(false) .standard(false) .attributes(ImmutableList.of(attr)); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem(new SearchGroupItem().addSearchParametersItem(pregParam)))); assertThat(resp) .isEqualTo( singleNestedQuery( NO_DATA_FILTERS, QueryBuilders.termsQuery("events.source_concept_id", ImmutableList.of(conceptId)), QueryBuilders.termsQuery("events.value_as_concept_id", ImmutableList.of(operand)))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testMeasurementCategoricalQuery() { String conceptId = "3015813"; String operand1 = "12345"; String operand2 = "12346"; Attribute attr = new Attribute() .name(AttrName.CAT) .operator(Operator.IN) .operands(ImmutableList.of(operand1, operand2)); SearchParameter measParam = new SearchParameter() .conceptId(Long.parseLong(conceptId)) .domain(DomainType.MEASUREMENT.toString()) .type(CriteriaType.LOINC.toString()) .group(false) .ancestorData(false) .standard(true) .attributes(ImmutableList.of(attr)); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem(new SearchGroupItem().addSearchParametersItem(measParam)))); assertThat(resp) .isEqualTo( singleNestedQuery( NO_DATA_FILTERS, QueryBuilders.termsQuery("events.concept_id", ImmutableList.of(conceptId)), QueryBuilders.termsQuery( "events.value_as_concept_id", ImmutableList.of(operand1, operand2)))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testNihStatus() throws Exception { FirecloudNihStatus status = new FirecloudNihStatus().linkedNihUsername("test").linkExpireTime(500L); when(nihApi.nihStatus()).thenReturn(status); assertThat(service.getNihStatus()).isNotNull(); assertThat(service.getNihStatus()).isEqualTo(status); }
|
@Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); static final List<String> FIRECLOUD_API_OAUTH_SCOPES; static final List<String> FIRECLOUD_WORKSPACE_REQUIRED_FIELDS; }
|
@Test public void testVisitQuery() { String conceptId = "9202"; SearchParameter visitParam = new SearchParameter() .conceptId(Long.parseLong(conceptId)) .domain(DomainType.VISIT.toString()) .type(CriteriaType.VISIT.toString()) .ancestorData(false) .standard(true) .group(false); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem(new SearchGroupItem().addSearchParametersItem(visitParam)))); assertThat(resp) .isEqualTo( singleNestedQuery( NO_DATA_FILTERS, QueryBuilders.termsQuery("events.concept_id", ImmutableList.of(conceptId)))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testAgeQuery() { OffsetDateTime now = OffsetDateTime.now(ZoneOffset.UTC); Object left = now.minusYears(34).minusYears(1).toLocalDate(); Object right = now.minusYears(20).toLocalDate(); SearchParameter ageParam = new SearchParameter() .domain(DomainType.PERSON.toString()) .type(CriteriaType.AGE.toString()) .group(false) .ancestorData(false) .standard(true) .addAttributesItem( new Attribute() .name(AttrName.AGE) .operator(Operator.BETWEEN) .operands(ImmutableList.of("20", "34"))); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem(new SearchGroupItem().addSearchParametersItem(ageParam)))); BoolQueryBuilder ageBuilder = QueryBuilders.boolQuery() .filter(QueryBuilders.termQuery("is_deceased", false)) .filter( QueryBuilders.rangeQuery("birth_datetime") .gte(left) .lte(right) .format("yyyy-MM-dd")); assertThat(resp).isEqualTo(nonNestedQuery(ageBuilder)); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testAgeAtConsentQuery() { OffsetDateTime now = OffsetDateTime.now(ZoneOffset.UTC); Object left = 20; Object right = 34; SearchParameter ageAtConsentParam = new SearchParameter() .domain(DomainType.PERSON.toString()) .type(CriteriaType.AGE.toString()) .group(false) .ancestorData(false) .standard(true) .addAttributesItem( new Attribute() .name(AttrName.AGE_AT_CONSENT) .operator(Operator.BETWEEN) .operands(ImmutableList.of("20", "34"))); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem( new SearchGroupItem().addSearchParametersItem(ageAtConsentParam)))); BoolQueryBuilder ageBuilder = QueryBuilders.boolQuery() .filter(QueryBuilders.termQuery("is_deceased", false)) .filter(QueryBuilders.rangeQuery("age_at_consent").gte(left).lte(right)); assertThat(resp).isEqualTo(nonNestedQuery(ageBuilder)); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testAgeAndEthnicityQuery() { OffsetDateTime now = OffsetDateTime.now(ZoneOffset.UTC); Object left = now.minusYears(34).minusYears(1).toLocalDate(); Object right = now.minusYears(20).toLocalDate(); SearchParameter ageParam = new SearchParameter() .domain(DomainType.PERSON.toString()) .type(CriteriaType.AGE.toString()) .group(false) .ancestorData(false) .standard(true) .addAttributesItem( new Attribute() .name(AttrName.AGE) .operator(Operator.BETWEEN) .operands(ImmutableList.of("20", "34"))); String conceptId = "38003563"; SearchParameter ethParam = new SearchParameter() .conceptId(Long.parseLong(conceptId)) .domain(DomainType.PERSON.toString()) .type(CriteriaType.ETHNICITY.toString()) .group(false) .ancestorData(false) .standard(true) .conceptId(Long.parseLong(conceptId)); QueryBuilder resp = ElasticFilters.fromCohortSearch( cbCriteriaDao, new SearchRequest() .addIncludesItem( new SearchGroup() .addItemsItem( new SearchGroupItem() .searchParameters(ImmutableList.of(ageParam, ethParam))))); BoolQueryBuilder ageBuilder = QueryBuilders.boolQuery() .filter(QueryBuilders.termQuery("is_deceased", false)) .filter( QueryBuilders.rangeQuery("birth_datetime") .gte(left) .lte(right) .format("yyyy-MM-dd")); assertThat(resp) .isEqualTo( nonNestedQuery( ageBuilder, QueryBuilders.termsQuery("ethnicity_concept_id", ImmutableList.of(conceptId)))); }
|
public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
ElasticFilters { public static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req) { ElasticFilters f = new ElasticFilters(cbCriteriaDao); return f.process(req); } private ElasticFilters(CBCriteriaDao cbCriteriaDao); static QueryBuilder fromCohortSearch(CBCriteriaDao cbCriteriaDao, SearchRequest req); }
|
@Test public void testRecord() { gaugeRecorderService.record(); verify(mockMonitoringService, atLeast(1)).recordBundles(measurementBundlesListCaptor.capture()); verify(mockWorkspaceServiceImpl).getGaugeData(); verify(mockBillingProjectBufferService).getGaugeData(); final List<Collection<MeasurementBundle>> allRecordedBundles = measurementBundlesListCaptor.getAllValues(); final int expectedSize = mockWorkspaceServiceImpl.getGaugeData().size() + mockBillingProjectBufferService.getGaugeData().size() + standAloneGaugeDataCollector.getGaugeData().size(); final int flatSize = allRecordedBundles.stream().map(Collection::size).mapToInt(Integer::valueOf).sum(); assertThat(flatSize).isEqualTo(expectedSize); final Optional<MeasurementBundle> workspacesBundle = allRecordedBundles.stream() .flatMap(Collection::stream) .filter(b -> b.getMeasurements().containsKey(GaugeMetric.WORKSPACE_COUNT)) .findFirst(); assertThat( workspacesBundle.map(MeasurementBundle::getMeasurements).orElse(Collections.emptyMap())) .hasSize(1); assertThat( workspacesBundle .map(wb -> wb.getMeasurements().get(GaugeMetric.WORKSPACE_COUNT)) .orElse(0)) .isEqualTo(WORKSPACES_COUNT); }
|
public void record() { logsBasedMetricService.recordElapsedTime( MeasurementBundle.builder(), DistributionMetric.GAUGE_COLLECTION_TIME, () -> { ImmutableList.Builder<MeasurementBundle> bundlesToLogBuilder = ImmutableList.builder(); for (GaugeDataCollector collector : gaugeDataCollectors) { Collection<MeasurementBundle> bundles = collector.getGaugeData(); monitoringService.recordBundles(bundles); bundlesToLogBuilder.addAll(bundles); } logValues(bundlesToLogBuilder.build()); }); }
|
GaugeRecorderService { public void record() { logsBasedMetricService.recordElapsedTime( MeasurementBundle.builder(), DistributionMetric.GAUGE_COLLECTION_TIME, () -> { ImmutableList.Builder<MeasurementBundle> bundlesToLogBuilder = ImmutableList.builder(); for (GaugeDataCollector collector : gaugeDataCollectors) { Collection<MeasurementBundle> bundles = collector.getGaugeData(); monitoringService.recordBundles(bundles); bundlesToLogBuilder.addAll(bundles); } logValues(bundlesToLogBuilder.build()); }); } }
|
GaugeRecorderService { public void record() { logsBasedMetricService.recordElapsedTime( MeasurementBundle.builder(), DistributionMetric.GAUGE_COLLECTION_TIME, () -> { ImmutableList.Builder<MeasurementBundle> bundlesToLogBuilder = ImmutableList.builder(); for (GaugeDataCollector collector : gaugeDataCollectors) { Collection<MeasurementBundle> bundles = collector.getGaugeData(); monitoringService.recordBundles(bundles); bundlesToLogBuilder.addAll(bundles); } logValues(bundlesToLogBuilder.build()); }); } GaugeRecorderService(
List<GaugeDataCollector> gaugeDataCollectors,
MonitoringService monitoringService,
LogsBasedMetricService logsBasedMetricService); }
|
GaugeRecorderService { public void record() { logsBasedMetricService.recordElapsedTime( MeasurementBundle.builder(), DistributionMetric.GAUGE_COLLECTION_TIME, () -> { ImmutableList.Builder<MeasurementBundle> bundlesToLogBuilder = ImmutableList.builder(); for (GaugeDataCollector collector : gaugeDataCollectors) { Collection<MeasurementBundle> bundles = collector.getGaugeData(); monitoringService.recordBundles(bundles); bundlesToLogBuilder.addAll(bundles); } logValues(bundlesToLogBuilder.build()); }); } GaugeRecorderService(
List<GaugeDataCollector> gaugeDataCollectors,
MonitoringService monitoringService,
LogsBasedMetricService logsBasedMetricService); void record(); }
|
GaugeRecorderService { public void record() { logsBasedMetricService.recordElapsedTime( MeasurementBundle.builder(), DistributionMetric.GAUGE_COLLECTION_TIME, () -> { ImmutableList.Builder<MeasurementBundle> bundlesToLogBuilder = ImmutableList.builder(); for (GaugeDataCollector collector : gaugeDataCollectors) { Collection<MeasurementBundle> bundles = collector.getGaugeData(); monitoringService.recordBundles(bundles); bundlesToLogBuilder.addAll(bundles); } logValues(bundlesToLogBuilder.build()); }); } GaugeRecorderService(
List<GaugeDataCollector> gaugeDataCollectors,
MonitoringService monitoringService,
LogsBasedMetricService logsBasedMetricService); void record(); }
|
@Test(expected = IllegalStateException.class) public void testBuild_unsupportedAttachmentValueThrows() { MeasurementBundle.builder() .addTag(MetricLabel.BUFFER_ENTRY_STATUS, "lost and gone forever") .build(); }
|
public static Builder builder() { return new Builder(); }
|
MeasurementBundle { public static Builder builder() { return new Builder(); } }
|
MeasurementBundle { public static Builder builder() { return new Builder(); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); }
|
MeasurementBundle { public static Builder builder() { return new Builder(); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
|
MeasurementBundle { public static Builder builder() { return new Builder(); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
|
@Test public void testGetTagValue() { final MeasurementBundle measurementBundle = MeasurementBundle.builder() .addMeasurement(GaugeMetric.BILLING_BUFFER_PROJECT_COUNT, 101L) .addTag(MetricLabel.BUFFER_ENTRY_STATUS, BufferEntryStatus.AVAILABLE.toString()) .build(); final Optional<String> labelValue = measurementBundle.getTagValue(MetricLabel.BUFFER_ENTRY_STATUS); assertThat(labelValue.isPresent()).isTrue(); assertThat(labelValue.orElse("wrong")).isEqualTo(BufferEntryStatus.AVAILABLE.toString()); final Optional<String> missingValue = measurementBundle.getTagValue(MetricLabel.METHOD_NAME); assertThat(missingValue.isPresent()).isFalse(); }
|
public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); }
|
MeasurementBundle { public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); } }
|
MeasurementBundle { public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); }
|
MeasurementBundle { public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
|
MeasurementBundle { public Optional<String> getTagValue(MetricLabel metricLabel) { return Optional.ofNullable(tags.get(metricLabel)).map(TagValue::asString); } private MeasurementBundle(Map<Metric, Number> measurements, Map<MetricLabel, TagValue> tags); Map<Metric, Number> getMeasurements(); Map<TagKey, TagValue> getTags(); Optional<String> getTagValue(MetricLabel metricLabel); static Builder builder(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
|
@Test public void testMakeMonitoredResource_noInstanceIdAvailable() { doThrow(ModulesException.class).when(mockModulesService).getCurrentInstanceId(); final MonitoredResource monitoredResource = exporterService.makeStackdriverStatsConfiguration().getMonitoredResource(); assertThat(monitoredResource.getLabelsMap().get("node_id")).isNotEmpty(); }
|
@VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); }
|
StackdriverStatsExporterService { @VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); } }
|
StackdriverStatsExporterService { @VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); } StackdriverStatsExporterService(
Provider<WorkbenchConfig> workbenchConfigProvider, ModulesService modulesService); }
|
StackdriverStatsExporterService { @VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); } StackdriverStatsExporterService(
Provider<WorkbenchConfig> workbenchConfigProvider, ModulesService modulesService); void createAndRegister(); @VisibleForTesting StackdriverStatsConfiguration makeStackdriverStatsConfiguration(); com.google.cloud.MonitoredResource getLoggingMonitoredResource(); }
|
StackdriverStatsExporterService { @VisibleForTesting public StackdriverStatsConfiguration makeStackdriverStatsConfiguration() { return StackdriverStatsConfiguration.builder() .setMetricNamePrefix(STACKDRIVER_CUSTOM_METRICS_PREFIX) .setProjectId(getProjectId()) .setMonitoredResource(getMonitoringMonitoredResource()) .build(); } StackdriverStatsExporterService(
Provider<WorkbenchConfig> workbenchConfigProvider, ModulesService modulesService); void createAndRegister(); @VisibleForTesting StackdriverStatsConfiguration makeStackdriverStatsConfiguration(); com.google.cloud.MonitoredResource getLoggingMonitoredResource(); static final String PROJECT_ID_LABEL; static final String LOCATION_LABEL; static final String NAMESPACE_LABEL; static final String NODE_ID_LABEL; static final String UNKNOWN_INSTANCE_PREFIX; static final Set<String> MONITORED_RESOURCE_LABELS; }
|
@Test public void testGetRuntime() throws ApiException { when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody()).isEqualTo(testRuntime); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_noLabel() throws ApiException { testLeoRuntime.setLabels(ImmutableMap.of()); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getConfigurationType()) .isEqualTo(RuntimeConfigurationType.HAILGENOMICANALYSIS); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testNihStatusNotFound() throws Exception { when(nihApi.nihStatus()).thenThrow(new ApiException(404, "Not Found")); assertThat(service.getNihStatus()).isNull(); }
|
@Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); static final List<String> FIRECLOUD_API_OAUTH_SCOPES; static final List<String> FIRECLOUD_WORKSPACE_REQUIRED_FIELDS; }
|
@Test public void testGetRuntime_defaultLabel_hail() throws ApiException { testLeoRuntime.setLabels(ImmutableMap.of("all-of-us-config", "preset-hail-genomic-analysis")); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getConfigurationType()) .isEqualTo(RuntimeConfigurationType.HAILGENOMICANALYSIS); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_defaultLabel_generalAnalysis() throws ApiException { testLeoRuntime.setLabels(ImmutableMap.of("all-of-us-config", "preset-general-analysis")); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getConfigurationType()) .isEqualTo(RuntimeConfigurationType.GENERALANALYSIS); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_overrideLabel() throws ApiException { testLeoRuntime.setLabels(ImmutableMap.of("all-of-us-config", "user-override")); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getConfigurationType()) .isEqualTo(RuntimeConfigurationType.USEROVERRIDE); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_noGetRuntime_emptyListRuntimes() throws ApiException { when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn(Collections.emptyList()); assertThrows(NotFoundException.class, () -> runtimeController.getRuntime(BILLING_PROJECT_ID)); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes() throws ApiException { String timestamp = "2020-09-13T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .googleProject("google-project") .runtimeName("expected-runtime") .status(LeonardoRuntimeStatus.CREATING) .auditInfo(new LeonardoAuditInfo().createdDate(timestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")))); Runtime runtime = runtimeController.getRuntime(BILLING_PROJECT_ID).getBody(); assertThat(runtime.getRuntimeName()).isEqualTo("expected-runtime"); assertThat(runtime.getGoogleProject()).isEqualTo("google-project"); assertThat(runtime.getStatus()).isEqualTo(RuntimeStatus.DELETED); assertThat(runtime.getConfigurationType()).isEqualTo(RuntimeConfigurationType.USEROVERRIDE); assertThat(runtime.getCreatedDate()).isEqualTo(timestamp); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_invalidRutime() throws ApiException { String timestamp = "2020-09-13T19:19:57.347Z"; dataprocConfigObj.put("cloudService", "notACloudService"); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeConfig(dataprocConfigObj) .labels(ImmutableMap.of("all-of-us-config", "user-override")))); assertThrows(NotFoundException.class, () -> runtimeController.getRuntime(BILLING_PROJECT_ID)); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_gceConfig() throws ApiException { String timestamp = "2020-09-13T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeConfig(gceConfigObj) .auditInfo(new LeonardoAuditInfo().createdDate(timestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")))); Runtime runtime = runtimeController.getRuntime(BILLING_PROJECT_ID).getBody(); assertThat(runtime.getGceConfig()).isEqualTo(gceConfig); assertThat(runtime.getDataprocConfig()).isNull(); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_dataprocConfig() throws ApiException { String timestamp = "2020-09-13T19:19:57.347Z"; LinkedTreeMap<String, Object> dataProcConfigObj = new LinkedTreeMap<>(); dataProcConfigObj.put("cloudService", "DATAPROC"); dataProcConfigObj.put("masterDiskSize", 50.0); dataProcConfigObj.put("masterMachineType", "n1-standard-4"); dataProcConfigObj.put("numberOfPreemptibleWorkers", 4); dataProcConfigObj.put("numberOfWorkerLocalSSDs", 8); dataProcConfigObj.put("numberOfWorkers", 3); dataProcConfigObj.put("workerDiskSize", 30); dataProcConfigObj.put("workerMachineType", "n1-standard-2"); when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeConfig(dataProcConfigObj) .auditInfo(new LeonardoAuditInfo().createdDate(timestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")))); Runtime runtime = runtimeController.getRuntime(BILLING_PROJECT_ID).getBody(); assertThat(runtime.getDataprocConfig().getMasterDiskSize()).isEqualTo(50); assertThat(runtime.getDataprocConfig().getMasterMachineType()).isEqualTo("n1-standard-4"); assertThat(runtime.getDataprocConfig().getNumberOfPreemptibleWorkers()).isEqualTo(4); assertThat(runtime.getDataprocConfig().getNumberOfWorkerLocalSSDs()).isEqualTo(8); assertThat(runtime.getDataprocConfig().getNumberOfWorkers()).isEqualTo(3); assertThat(runtime.getDataprocConfig().getWorkerDiskSize()).isEqualTo(30); assertThat(runtime.getDataprocConfig().getWorkerMachineType()).isEqualTo("n1-standard-2"); assertThat(runtime.getGceConfig()).isNull(); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_checkMostRecent() throws ApiException { String olderTimestamp = "2020-09-13T19:19:57.347Z"; String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("expected-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(olderTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getRuntimeName()) .isEqualTo("expected-runtime"); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_checkMostRecent_nullAuditInfo() throws ApiException { String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("expected-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getRuntimeName()) .isEqualTo("expected-runtime"); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test(expected = ServerErrorException.class) public void testNihStatusException() throws Exception { when(nihApi.nihStatus()).thenThrow(new ApiException(500, "Internal Server Error")); service.getNihStatus(); }
|
@Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); }
|
FireCloudServiceImpl implements FireCloudService { @Override public FirecloudNihStatus getNihStatus() { NihApi nihApi = nihApiProvider.get(); return retryHandler.run( (context) -> { try { return nihApi.nihStatus(); } catch (ApiException e) { if (e.getCode() == HttpStatusCodes.STATUS_CODE_NOT_FOUND) { return null; } else { throw e; } } }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); static final List<String> FIRECLOUD_API_OAUTH_SCOPES; static final List<String> FIRECLOUD_WORKSPACE_REQUIRED_FIELDS; }
|
@Test public void testGetRuntime_fromListRuntimes_checkMostRecent_nullTimestamp() throws ApiException { String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("expected-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(null)) .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getRuntimeName()) .isEqualTo("expected-runtime"); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntimes_checkMostRecent_emptyTimestamp() throws ApiException { String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("expected-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .auditInfo(new LeonardoAuditInfo().createdDate("")) .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getRuntimeName()) .isEqualTo("expected-runtime"); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntime_mostRecentIsDefaultLabel() throws ApiException { String olderTimestamp = "2020-09-13T19:19:57.347Z"; String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("override-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(olderTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "user-override")), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThrows(NotFoundException.class, () -> runtimeController.getRuntime(BILLING_PROJECT_ID)); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_fromListRuntime_mostRecentHasNoLabel() throws ApiException { String olderTimestamp = "2020-09-13T19:19:57.347Z"; String newerTimestamp = "2020-09-14T19:19:57.347Z"; when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenThrow(new ApiException(404, "Not found")); when(userRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, true)) .thenReturn( ImmutableList.of( new LeonardoListRuntimeResponse() .runtimeName("override-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(newerTimestamp)), new LeonardoListRuntimeResponse() .runtimeName("default-runtime") .auditInfo(new LeonardoAuditInfo().createdDate(olderTimestamp)) .labels(ImmutableMap.of("all-of-us-config", "default")))); assertThrows(NotFoundException.class, () -> runtimeController.getRuntime(BILLING_PROJECT_ID)); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_gceConfig() throws ApiException { when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime.runtimeConfig(gceConfigObj)); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody()) .isEqualTo(testRuntime.dataprocConfig(null).gceConfig(gceConfig)); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testGetRuntime_UnknownStatus() throws ApiException { when(userRuntimesApi.getRuntime(BILLING_PROJECT_ID, getRuntimeName())) .thenReturn(testLeoRuntime.status(null)); assertThat(runtimeController.getRuntime(BILLING_PROJECT_ID).getBody().getStatus()) .isEqualTo(RuntimeStatus.UNKNOWN); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test(expected = NotFoundException.class) public void testGetRuntime_NullBillingProject() { runtimeController.getRuntime(null); }
|
@Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<Runtime> getRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling(workspaceNamespace, firecloudWorkspaceName); try { return ResponseEntity.ok( leonardoMapper.toApiRuntime( leonardoNotebooksClient.getRuntime( workspaceNamespace, userProvider.get().getRuntimeName()))); } catch (NotFoundException e) { if (!workbenchConfigProvider.get().featureFlags.enableCustomRuntimes) { throw e; } return ResponseEntity.ok(getOverrideFromListRuntimes(workspaceNamespace)); } } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testDeleteRuntimesInProject() throws ApiException { List<LeonardoListRuntimeResponse> listRuntimeResponseList = ImmutableList.of(testLeoListRuntimeResponse); when(serviceRuntimesApi.listRuntimesByProject(BILLING_PROJECT_ID, null, false)) .thenReturn(listRuntimeResponseList); runtimeController.deleteRuntimesInProject( BILLING_PROJECT_ID, new ListRuntimeDeleteRequest() .runtimesToDelete(ImmutableList.of(testLeoRuntime.getRuntimeName()))); verify(serviceRuntimesApi) .deleteRuntime(BILLING_PROJECT_ID, testLeoRuntime.getRuntimeName(), false); verify(mockLeonardoRuntimeAuditor) .fireDeleteRuntimesInProject( BILLING_PROJECT_ID, listRuntimeResponseList.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); }
|
@Override @AuthorityRequired(Authority.SECURITY_ADMIN) public ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject( String billingProjectId, ListRuntimeDeleteRequest req) { if (billingProjectId == null) { throw new BadRequestException("Must specify billing project"); } List<LeonardoListRuntimeResponse> runtimesToDelete = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); runtimesToDelete.forEach( runtime -> leonardoNotebooksClient.deleteRuntimeAsService( runtime.getGoogleProject(), runtime.getRuntimeName())); List<LeonardoListRuntimeResponse> runtimesInProjectAffected = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); List<LeonardoRuntimeStatus> acceptableStates = ImmutableList.of(LeonardoRuntimeStatus.DELETING, LeonardoRuntimeStatus.ERROR); runtimesInProjectAffected.stream() .filter(runtime -> !acceptableStates.contains(runtime.getStatus())) .forEach( clusterInBadState -> log.log( Level.SEVERE, String.format( "Runtime %s/%s is not in a deleting state", clusterInBadState.getGoogleProject(), clusterInBadState.getRuntimeName()))); leonardoRuntimeAuditor.fireDeleteRuntimesInProject( billingProjectId, runtimesToDelete.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); return ResponseEntity.ok( runtimesInProjectAffected.stream() .map(leonardoMapper::toApiListRuntimeResponse) .collect(Collectors.toList())); }
|
RuntimeController implements RuntimeApiDelegate { @Override @AuthorityRequired(Authority.SECURITY_ADMIN) public ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject( String billingProjectId, ListRuntimeDeleteRequest req) { if (billingProjectId == null) { throw new BadRequestException("Must specify billing project"); } List<LeonardoListRuntimeResponse> runtimesToDelete = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); runtimesToDelete.forEach( runtime -> leonardoNotebooksClient.deleteRuntimeAsService( runtime.getGoogleProject(), runtime.getRuntimeName())); List<LeonardoListRuntimeResponse> runtimesInProjectAffected = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); List<LeonardoRuntimeStatus> acceptableStates = ImmutableList.of(LeonardoRuntimeStatus.DELETING, LeonardoRuntimeStatus.ERROR); runtimesInProjectAffected.stream() .filter(runtime -> !acceptableStates.contains(runtime.getStatus())) .forEach( clusterInBadState -> log.log( Level.SEVERE, String.format( "Runtime %s/%s is not in a deleting state", clusterInBadState.getGoogleProject(), clusterInBadState.getRuntimeName()))); leonardoRuntimeAuditor.fireDeleteRuntimesInProject( billingProjectId, runtimesToDelete.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); return ResponseEntity.ok( runtimesInProjectAffected.stream() .map(leonardoMapper::toApiListRuntimeResponse) .collect(Collectors.toList())); } }
|
RuntimeController implements RuntimeApiDelegate { @Override @AuthorityRequired(Authority.SECURITY_ADMIN) public ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject( String billingProjectId, ListRuntimeDeleteRequest req) { if (billingProjectId == null) { throw new BadRequestException("Must specify billing project"); } List<LeonardoListRuntimeResponse> runtimesToDelete = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); runtimesToDelete.forEach( runtime -> leonardoNotebooksClient.deleteRuntimeAsService( runtime.getGoogleProject(), runtime.getRuntimeName())); List<LeonardoListRuntimeResponse> runtimesInProjectAffected = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); List<LeonardoRuntimeStatus> acceptableStates = ImmutableList.of(LeonardoRuntimeStatus.DELETING, LeonardoRuntimeStatus.ERROR); runtimesInProjectAffected.stream() .filter(runtime -> !acceptableStates.contains(runtime.getStatus())) .forEach( clusterInBadState -> log.log( Level.SEVERE, String.format( "Runtime %s/%s is not in a deleting state", clusterInBadState.getGoogleProject(), clusterInBadState.getRuntimeName()))); leonardoRuntimeAuditor.fireDeleteRuntimesInProject( billingProjectId, runtimesToDelete.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); return ResponseEntity.ok( runtimesInProjectAffected.stream() .map(leonardoMapper::toApiListRuntimeResponse) .collect(Collectors.toList())); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override @AuthorityRequired(Authority.SECURITY_ADMIN) public ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject( String billingProjectId, ListRuntimeDeleteRequest req) { if (billingProjectId == null) { throw new BadRequestException("Must specify billing project"); } List<LeonardoListRuntimeResponse> runtimesToDelete = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); runtimesToDelete.forEach( runtime -> leonardoNotebooksClient.deleteRuntimeAsService( runtime.getGoogleProject(), runtime.getRuntimeName())); List<LeonardoListRuntimeResponse> runtimesInProjectAffected = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); List<LeonardoRuntimeStatus> acceptableStates = ImmutableList.of(LeonardoRuntimeStatus.DELETING, LeonardoRuntimeStatus.ERROR); runtimesInProjectAffected.stream() .filter(runtime -> !acceptableStates.contains(runtime.getStatus())) .forEach( clusterInBadState -> log.log( Level.SEVERE, String.format( "Runtime %s/%s is not in a deleting state", clusterInBadState.getGoogleProject(), clusterInBadState.getRuntimeName()))); leonardoRuntimeAuditor.fireDeleteRuntimesInProject( billingProjectId, runtimesToDelete.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); return ResponseEntity.ok( runtimesInProjectAffected.stream() .map(leonardoMapper::toApiListRuntimeResponse) .collect(Collectors.toList())); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override @AuthorityRequired(Authority.SECURITY_ADMIN) public ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject( String billingProjectId, ListRuntimeDeleteRequest req) { if (billingProjectId == null) { throw new BadRequestException("Must specify billing project"); } List<LeonardoListRuntimeResponse> runtimesToDelete = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); runtimesToDelete.forEach( runtime -> leonardoNotebooksClient.deleteRuntimeAsService( runtime.getGoogleProject(), runtime.getRuntimeName())); List<LeonardoListRuntimeResponse> runtimesInProjectAffected = filterByRuntimesInList( leonardoNotebooksClient.listRuntimesByProjectAsService(billingProjectId).stream(), req.getRuntimesToDelete()) .collect(Collectors.toList()); List<LeonardoRuntimeStatus> acceptableStates = ImmutableList.of(LeonardoRuntimeStatus.DELETING, LeonardoRuntimeStatus.ERROR); runtimesInProjectAffected.stream() .filter(runtime -> !acceptableStates.contains(runtime.getStatus())) .forEach( clusterInBadState -> log.log( Level.SEVERE, String.format( "Runtime %s/%s is not in a deleting state", clusterInBadState.getGoogleProject(), clusterInBadState.getRuntimeName()))); leonardoRuntimeAuditor.fireDeleteRuntimesInProject( billingProjectId, runtimesToDelete.stream() .map(LeonardoListRuntimeResponse::getRuntimeName) .collect(Collectors.toList())); return ResponseEntity.ok( runtimesInProjectAffected.stream() .map(leonardoMapper::toApiListRuntimeResponse) .collect(Collectors.toList())); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testDeleteRuntime() throws ApiException { runtimeController.deleteRuntime(BILLING_PROJECT_ID); verify(userRuntimesApi).deleteRuntime(BILLING_PROJECT_ID, getRuntimeName(), false); }
|
@Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace) { String firecloudWorkspaceName = lookupWorkspace(workspaceNamespace).getFirecloudName(); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( workspaceNamespace, firecloudWorkspaceName, WorkspaceAccessLevel.WRITER); leonardoNotebooksClient.deleteRuntime(workspaceNamespace, userProvider.get().getRuntimeName()); return ResponseEntity.ok(new EmptyResponse()); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testLocalize() throws org.pmiops.workbench.notebooks.ApiException { RuntimeLocalizeRequest req = new RuntimeLocalizeRequest() .notebookNames(ImmutableList.of("foo.ipynb")) .playgroundMode(false); stubGetWorkspace(WORKSPACE_NS, WORKSPACE_ID, LOGGED_IN_USER_EMAIL); RuntimeLocalizeResponse resp = runtimeController.localize(BILLING_PROJECT_ID, req).getBody(); assertThat(resp.getRuntimeLocalDirectory()).isEqualTo("workspaces/myfirstworkspace"); verify(proxyApi) .welderLocalize(eq(BILLING_PROJECT_ID), eq(getRuntimeName()), welderReqCaptor.capture()); Localize welderReq = welderReqCaptor.getValue(); assertThat( welderReq.getEntries().stream() .map(e -> e.getLocalDestinationPath()) .collect(Collectors.toList())) .containsExactly( "workspaces/myfirstworkspace/foo.ipynb", "workspaces_playground/myfirstworkspace/.all_of_us_config.json", "workspaces/myfirstworkspace/.all_of_us_config.json"); assertThat( welderReq.getEntries().stream() .filter( e -> e.getSourceUri().equals("gs: && e.getLocalDestinationPath() .equals("workspaces/myfirstworkspace/foo.ipynb")) .count()) .isAtLeast(1L); JSONObject aouJson = dataUriToJson( welderReq.getEntries().stream() .filter( e -> e.getLocalDestinationPath() .equals("workspaces/myfirstworkspace/.all_of_us_config.json")) .findFirst() .get() .getSourceUri()); assertThat(aouJson.getString("WORKSPACE_ID")).isEqualTo(WORKSPACE_ID); assertThat(aouJson.getString("BILLING_CLOUD_PROJECT")).isEqualTo(BILLING_PROJECT_ID); assertThat(aouJson.getString("API_HOST")).isEqualTo(API_HOST); verify(mockUserRecentResourceService, times(1)) .updateNotebookEntry(anyLong(), anyLong(), anyString()); }
|
@Override public ResponseEntity<RuntimeLocalizeResponse> localize( String workspaceNamespace, RuntimeLocalizeRequest body) { DbWorkspace dbWorkspace = lookupWorkspace(workspaceNamespace); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName(), WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()); final FirecloudWorkspace firecloudWorkspace; try { firecloudWorkspace = fireCloudService .getWorkspace(dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()) .getWorkspace(); } catch (NotFoundException e) { throw new NotFoundException( String.format( "workspace %s/%s not found or not accessible", dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName())); } DbCdrVersion cdrVersion = dbWorkspace.getCdrVersion(); String gcsNotebooksDir = "gs: long workspaceId = dbWorkspace.getWorkspaceId(); body.getNotebookNames() .forEach( notebookName -> userRecentResourceService.updateNotebookEntry( workspaceId, userProvider.get().getUserId(), gcsNotebooksDir + "/" + notebookName)); String workspacePath = dbWorkspace.getFirecloudName(); String editDir = "workspaces/" + workspacePath; String playgroundDir = "workspaces_playground/" + workspacePath; String targetDir = body.getPlaygroundMode() ? playgroundDir : editDir; leonardoNotebooksClient.createStorageLink( workspaceNamespace, userProvider.get().getRuntimeName(), new StorageLink() .cloudStorageDirectory(gcsNotebooksDir) .localBaseDirectory(editDir) .localSafeModeBaseDirectory(playgroundDir) .pattern(DELOC_PATTERN)); Map<String, String> localizeMap = new HashMap<>(); String aouConfigUri = aouConfigDataUri(firecloudWorkspace, cdrVersion, workspaceNamespace); localizeMap.put(editDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); localizeMap.put(playgroundDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); if (body.getNotebookNames() != null) { localizeMap.putAll( body.getNotebookNames().stream() .collect( Collectors.toMap( name -> targetDir + "/" + name, name -> gcsNotebooksDir + "/" + name))); } log.info(localizeMap.toString()); leonardoNotebooksClient.localize( workspaceNamespace, userProvider.get().getRuntimeName(), localizeMap); return ResponseEntity.ok(new RuntimeLocalizeResponse().runtimeLocalDirectory(targetDir)); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<RuntimeLocalizeResponse> localize( String workspaceNamespace, RuntimeLocalizeRequest body) { DbWorkspace dbWorkspace = lookupWorkspace(workspaceNamespace); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName(), WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()); final FirecloudWorkspace firecloudWorkspace; try { firecloudWorkspace = fireCloudService .getWorkspace(dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()) .getWorkspace(); } catch (NotFoundException e) { throw new NotFoundException( String.format( "workspace %s/%s not found or not accessible", dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName())); } DbCdrVersion cdrVersion = dbWorkspace.getCdrVersion(); String gcsNotebooksDir = "gs: long workspaceId = dbWorkspace.getWorkspaceId(); body.getNotebookNames() .forEach( notebookName -> userRecentResourceService.updateNotebookEntry( workspaceId, userProvider.get().getUserId(), gcsNotebooksDir + "/" + notebookName)); String workspacePath = dbWorkspace.getFirecloudName(); String editDir = "workspaces/" + workspacePath; String playgroundDir = "workspaces_playground/" + workspacePath; String targetDir = body.getPlaygroundMode() ? playgroundDir : editDir; leonardoNotebooksClient.createStorageLink( workspaceNamespace, userProvider.get().getRuntimeName(), new StorageLink() .cloudStorageDirectory(gcsNotebooksDir) .localBaseDirectory(editDir) .localSafeModeBaseDirectory(playgroundDir) .pattern(DELOC_PATTERN)); Map<String, String> localizeMap = new HashMap<>(); String aouConfigUri = aouConfigDataUri(firecloudWorkspace, cdrVersion, workspaceNamespace); localizeMap.put(editDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); localizeMap.put(playgroundDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); if (body.getNotebookNames() != null) { localizeMap.putAll( body.getNotebookNames().stream() .collect( Collectors.toMap( name -> targetDir + "/" + name, name -> gcsNotebooksDir + "/" + name))); } log.info(localizeMap.toString()); leonardoNotebooksClient.localize( workspaceNamespace, userProvider.get().getRuntimeName(), localizeMap); return ResponseEntity.ok(new RuntimeLocalizeResponse().runtimeLocalDirectory(targetDir)); } }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<RuntimeLocalizeResponse> localize( String workspaceNamespace, RuntimeLocalizeRequest body) { DbWorkspace dbWorkspace = lookupWorkspace(workspaceNamespace); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName(), WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()); final FirecloudWorkspace firecloudWorkspace; try { firecloudWorkspace = fireCloudService .getWorkspace(dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()) .getWorkspace(); } catch (NotFoundException e) { throw new NotFoundException( String.format( "workspace %s/%s not found or not accessible", dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName())); } DbCdrVersion cdrVersion = dbWorkspace.getCdrVersion(); String gcsNotebooksDir = "gs: long workspaceId = dbWorkspace.getWorkspaceId(); body.getNotebookNames() .forEach( notebookName -> userRecentResourceService.updateNotebookEntry( workspaceId, userProvider.get().getUserId(), gcsNotebooksDir + "/" + notebookName)); String workspacePath = dbWorkspace.getFirecloudName(); String editDir = "workspaces/" + workspacePath; String playgroundDir = "workspaces_playground/" + workspacePath; String targetDir = body.getPlaygroundMode() ? playgroundDir : editDir; leonardoNotebooksClient.createStorageLink( workspaceNamespace, userProvider.get().getRuntimeName(), new StorageLink() .cloudStorageDirectory(gcsNotebooksDir) .localBaseDirectory(editDir) .localSafeModeBaseDirectory(playgroundDir) .pattern(DELOC_PATTERN)); Map<String, String> localizeMap = new HashMap<>(); String aouConfigUri = aouConfigDataUri(firecloudWorkspace, cdrVersion, workspaceNamespace); localizeMap.put(editDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); localizeMap.put(playgroundDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); if (body.getNotebookNames() != null) { localizeMap.putAll( body.getNotebookNames().stream() .collect( Collectors.toMap( name -> targetDir + "/" + name, name -> gcsNotebooksDir + "/" + name))); } log.info(localizeMap.toString()); leonardoNotebooksClient.localize( workspaceNamespace, userProvider.get().getRuntimeName(), localizeMap); return ResponseEntity.ok(new RuntimeLocalizeResponse().runtimeLocalDirectory(targetDir)); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<RuntimeLocalizeResponse> localize( String workspaceNamespace, RuntimeLocalizeRequest body) { DbWorkspace dbWorkspace = lookupWorkspace(workspaceNamespace); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName(), WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()); final FirecloudWorkspace firecloudWorkspace; try { firecloudWorkspace = fireCloudService .getWorkspace(dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()) .getWorkspace(); } catch (NotFoundException e) { throw new NotFoundException( String.format( "workspace %s/%s not found or not accessible", dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName())); } DbCdrVersion cdrVersion = dbWorkspace.getCdrVersion(); String gcsNotebooksDir = "gs: long workspaceId = dbWorkspace.getWorkspaceId(); body.getNotebookNames() .forEach( notebookName -> userRecentResourceService.updateNotebookEntry( workspaceId, userProvider.get().getUserId(), gcsNotebooksDir + "/" + notebookName)); String workspacePath = dbWorkspace.getFirecloudName(); String editDir = "workspaces/" + workspacePath; String playgroundDir = "workspaces_playground/" + workspacePath; String targetDir = body.getPlaygroundMode() ? playgroundDir : editDir; leonardoNotebooksClient.createStorageLink( workspaceNamespace, userProvider.get().getRuntimeName(), new StorageLink() .cloudStorageDirectory(gcsNotebooksDir) .localBaseDirectory(editDir) .localSafeModeBaseDirectory(playgroundDir) .pattern(DELOC_PATTERN)); Map<String, String> localizeMap = new HashMap<>(); String aouConfigUri = aouConfigDataUri(firecloudWorkspace, cdrVersion, workspaceNamespace); localizeMap.put(editDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); localizeMap.put(playgroundDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); if (body.getNotebookNames() != null) { localizeMap.putAll( body.getNotebookNames().stream() .collect( Collectors.toMap( name -> targetDir + "/" + name, name -> gcsNotebooksDir + "/" + name))); } log.info(localizeMap.toString()); leonardoNotebooksClient.localize( workspaceNamespace, userProvider.get().getRuntimeName(), localizeMap); return ResponseEntity.ok(new RuntimeLocalizeResponse().runtimeLocalDirectory(targetDir)); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
RuntimeController implements RuntimeApiDelegate { @Override public ResponseEntity<RuntimeLocalizeResponse> localize( String workspaceNamespace, RuntimeLocalizeRequest body) { DbWorkspace dbWorkspace = lookupWorkspace(workspaceNamespace); workspaceService.enforceWorkspaceAccessLevelAndRegisteredAuthDomain( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName(), WorkspaceAccessLevel.WRITER); workspaceService.validateActiveBilling( dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()); final FirecloudWorkspace firecloudWorkspace; try { firecloudWorkspace = fireCloudService .getWorkspace(dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName()) .getWorkspace(); } catch (NotFoundException e) { throw new NotFoundException( String.format( "workspace %s/%s not found or not accessible", dbWorkspace.getWorkspaceNamespace(), dbWorkspace.getFirecloudName())); } DbCdrVersion cdrVersion = dbWorkspace.getCdrVersion(); String gcsNotebooksDir = "gs: long workspaceId = dbWorkspace.getWorkspaceId(); body.getNotebookNames() .forEach( notebookName -> userRecentResourceService.updateNotebookEntry( workspaceId, userProvider.get().getUserId(), gcsNotebooksDir + "/" + notebookName)); String workspacePath = dbWorkspace.getFirecloudName(); String editDir = "workspaces/" + workspacePath; String playgroundDir = "workspaces_playground/" + workspacePath; String targetDir = body.getPlaygroundMode() ? playgroundDir : editDir; leonardoNotebooksClient.createStorageLink( workspaceNamespace, userProvider.get().getRuntimeName(), new StorageLink() .cloudStorageDirectory(gcsNotebooksDir) .localBaseDirectory(editDir) .localSafeModeBaseDirectory(playgroundDir) .pattern(DELOC_PATTERN)); Map<String, String> localizeMap = new HashMap<>(); String aouConfigUri = aouConfigDataUri(firecloudWorkspace, cdrVersion, workspaceNamespace); localizeMap.put(editDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); localizeMap.put(playgroundDir + "/" + AOU_CONFIG_FILENAME, aouConfigUri); if (body.getNotebookNames() != null) { localizeMap.putAll( body.getNotebookNames().stream() .collect( Collectors.toMap( name -> targetDir + "/" + name, name -> gcsNotebooksDir + "/" + name))); } log.info(localizeMap.toString()); leonardoNotebooksClient.localize( workspaceNamespace, userProvider.get().getRuntimeName(), localizeMap); return ResponseEntity.ok(new RuntimeLocalizeResponse().runtimeLocalDirectory(targetDir)); } @Autowired RuntimeController(
LeonardoRuntimeAuditor leonardoRuntimeAuditor,
LeonardoNotebooksClient leonardoNotebooksClient,
Provider<DbUser> userProvider,
WorkspaceService workspaceService,
FireCloudService fireCloudService,
Provider<WorkbenchConfig> workbenchConfigProvider,
UserService userService,
UserRecentResourceService userRecentResourceService,
UserDao userDao,
LeonardoMapper leonardoMapper,
Clock clock); @Override @AuthorityRequired(Authority.SECURITY_ADMIN) ResponseEntity<List<ListRuntimeResponse>> deleteRuntimesInProject(
String billingProjectId, ListRuntimeDeleteRequest req); @Override ResponseEntity<Runtime> getRuntime(String workspaceNamespace); @Override ResponseEntity<EmptyResponse> createRuntime(String workspaceNamespace, Runtime runtime); @Override ResponseEntity<EmptyResponse> deleteRuntime(String workspaceNamespace); @Override ResponseEntity<RuntimeLocalizeResponse> localize(
String workspaceNamespace, RuntimeLocalizeRequest body); @Override @AuthorityRequired({Authority.DEVELOPER}) ResponseEntity<EmptyResponse> updateClusterConfig(UpdateClusterConfigRequest body); }
|
@Test public void testNihCallback() throws Exception { FirecloudJWTWrapper jwt = new FirecloudJWTWrapper().jwt("asdf"); service.postNihCallback(jwt); verify(nihApi, times(1)).nihCallback(jwt); }
|
@Override public void postNihCallback(FirecloudJWTWrapper wrapper) { NihApi nihApi = nihApiProvider.get(); retryHandler.run( (context) -> { return nihApi.nihCallback(wrapper); }); }
|
FireCloudServiceImpl implements FireCloudService { @Override public void postNihCallback(FirecloudJWTWrapper wrapper) { NihApi nihApi = nihApiProvider.get(); retryHandler.run( (context) -> { return nihApi.nihCallback(wrapper); }); } }
|
FireCloudServiceImpl implements FireCloudService { @Override public void postNihCallback(FirecloudJWTWrapper wrapper) { NihApi nihApi = nihApiProvider.get(); retryHandler.run( (context) -> { return nihApi.nihCallback(wrapper); }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); }
|
FireCloudServiceImpl implements FireCloudService { @Override public void postNihCallback(FirecloudJWTWrapper wrapper) { NihApi nihApi = nihApiProvider.get(); retryHandler.run( (context) -> { return nihApi.nihCallback(wrapper); }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); }
|
FireCloudServiceImpl implements FireCloudService { @Override public void postNihCallback(FirecloudJWTWrapper wrapper) { NihApi nihApi = nihApiProvider.get(); retryHandler.run( (context) -> { return nihApi.nihCallback(wrapper); }); } @Autowired FireCloudServiceImpl(
Provider<WorkbenchConfig> configProvider,
Provider<ProfileApi> profileApiProvider,
Provider<BillingApi> billingApiProvider,
Provider<GroupsApi> groupsApiProvider,
Provider<NihApi> nihApiProvider,
@Qualifier(FireCloudConfig.END_USER_WORKSPACE_API)
Provider<WorkspacesApi> endUserWorkspacesApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_WORKSPACE_API)
Provider<WorkspacesApi> serviceAccountWorkspaceApiProvider,
Provider<StatusApi> statusApiProvider,
@Qualifier(FireCloudConfig.END_USER_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> endUserStaticNotebooksApiProvider,
@Qualifier(FireCloudConfig.SERVICE_ACCOUNT_STATIC_NOTEBOOKS_API)
Provider<StaticNotebooksApi> serviceAccountStaticNotebooksApiProvider,
FirecloudRetryHandler retryHandler,
@Qualifier(Constants.FIRECLOUD_ADMIN_CREDS)
Provider<ServiceAccountCredentials> fcAdminCredsProvider,
IamCredentialsClient iamCredentialsClient,
HttpTransport httpTransport); ApiClient getApiClientWithImpersonation(String userEmail); @Override @VisibleForTesting String getApiBasePath(); @Override boolean getFirecloudStatus(); @Override FirecloudMe getMe(); @Override void registerUser(String contactEmail, String firstName, String lastName); @Override void createAllOfUsBillingProject(String projectName); @Override void deleteBillingProject(String billingProject); @Override FirecloudBillingProjectStatus getBillingProjectStatus(String projectName); @Override void addOwnerToBillingProject(String ownerEmail, String projectName); @Override void removeOwnerFromBillingProject(
String ownerEmailToRemove, String projectName, Optional<String> callerAccessToken); @Override FirecloudWorkspace createWorkspace(String projectName, String workspaceName); @Override FirecloudWorkspace cloneWorkspace(
String fromProject, String fromName, String toProject, String toName); @Override List<FirecloudBillingProjectMembership> getBillingProjectMemberships(); @Override FirecloudWorkspaceACLUpdateResponseList updateWorkspaceACL(
String projectName, String workspaceName, List<FirecloudWorkspaceACLUpdate> aclUpdates); @Override FirecloudWorkspaceACL getWorkspaceAclAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspaceAsService(String projectName, String workspaceName); @Override FirecloudWorkspaceResponse getWorkspace(String projectName, String workspaceName); @Override Optional<FirecloudWorkspaceResponse> getWorkspace(DbWorkspace dbWorkspace); @Override List<FirecloudWorkspaceResponse> getWorkspaces(); @Override void deleteWorkspace(String projectName, String workspaceName); @Override FirecloudManagedGroupWithMembers getGroup(String groupName); @Override FirecloudManagedGroupWithMembers createGroup(String groupName); @Override void addUserToGroup(String email, String groupName); @Override void removeUserFromGroup(String email, String groupName); @Override boolean isUserMemberOfGroup(String email, String groupName); @Override String staticNotebooksConvert(byte[] notebook); @Override String staticNotebooksConvertAsService(byte[] notebook); @Override FirecloudNihStatus getNihStatus(); @Override void postNihCallback(FirecloudJWTWrapper wrapper); static final List<String> FIRECLOUD_API_OAUTH_SCOPES; static final List<String> FIRECLOUD_WORKSPACE_REQUIRED_FIELDS; }
|
@Test public void test_utilities_createdThroughS3Client() throws MalformedURLException { assertThat(defaultUtilities.getUrl(requestWithoutSpaces()) .toExternalForm()) .isEqualTo("https: assertThat(defaultUtilities.getUrl(requestWithSpecialCharacters()) .toExternalForm()) .isEqualTo("https: }
|
public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); }
|
S3Utilities { public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); } }
|
S3Utilities { public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); } private S3Utilities(Builder builder); }
|
S3Utilities { public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }
|
S3Utilities { public URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest) { return getUrl(GetUrlRequest.builder().applyMutation(getUrlRequest).build()); } private S3Utilities(Builder builder); static Builder builder(); URL getUrl(Consumer<GetUrlRequest.Builder> getUrlRequest); URL getUrl(GetUrlRequest getUrlRequest); }
|
@Test public void testSinglePacket() { final TestPublisher driver = new TestPublisher(); final TestSubscriber s = new TestSubscriber(Arrays.copyOfRange(testData, 0, TEST_DATA_SIZE)); final ChecksumValidatingPublisher p = new ChecksumValidatingPublisher(driver, new Md5Checksum(), TEST_DATA_SIZE + CHECKSUM_SIZE); p.subscribe(s); driver.doOnNext(ByteBuffer.wrap(testData)); driver.doOnComplete(); assertTrue(s.hasCompleted()); assertFalse(s.isOnErrorCalled()); }
|
@Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
@Test public void testTwoPackets() { for (int i = 1; i < TEST_DATA_SIZE + CHECKSUM_SIZE - 1; i++) { final TestPublisher driver = new TestPublisher(); final TestSubscriber s = new TestSubscriber(Arrays.copyOfRange(testData, 0, TEST_DATA_SIZE)); final ChecksumValidatingPublisher p = new ChecksumValidatingPublisher(driver, new Md5Checksum(), TEST_DATA_SIZE + CHECKSUM_SIZE); p.subscribe(s); driver.doOnNext(ByteBuffer.wrap(testData, 0, i)); driver.doOnNext(ByteBuffer.wrap(testData, i, TEST_DATA_SIZE + CHECKSUM_SIZE - i)); driver.doOnComplete(); assertTrue(s.hasCompleted()); assertFalse(s.isOnErrorCalled()); } }
|
@Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
@Test public void testTinyPackets() { for (int packetSize = 1; packetSize < CHECKSUM_SIZE; packetSize++) { final TestPublisher driver = new TestPublisher(); final TestSubscriber s = new TestSubscriber(Arrays.copyOfRange(testData, 0, TEST_DATA_SIZE)); final ChecksumValidatingPublisher p = new ChecksumValidatingPublisher(driver, new Md5Checksum(), TEST_DATA_SIZE + CHECKSUM_SIZE); p.subscribe(s); int currOffset = 0; while (currOffset < TEST_DATA_SIZE + CHECKSUM_SIZE) { final int toSend = Math.min(packetSize, TEST_DATA_SIZE + CHECKSUM_SIZE - currOffset); driver.doOnNext(ByteBuffer.wrap(testData, currOffset, toSend)); currOffset += toSend; } driver.doOnComplete(); assertTrue(s.hasCompleted()); assertFalse(s.isOnErrorCalled()); } }
|
@Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
@Test public void testUnknownLength() { final TestPublisher driver = new TestPublisher(); final TestSubscriber s = new TestSubscriber(Arrays.copyOfRange(testData, 0, TEST_DATA_SIZE)); final ChecksumValidatingPublisher p = new ChecksumValidatingPublisher(driver, new Md5Checksum(), 0); p.subscribe(s); byte[] randomChecksumData = new byte[testData.length]; System.arraycopy(testData, 0, randomChecksumData, 0, TEST_DATA_SIZE); for (int i = TEST_DATA_SIZE; i < randomChecksumData.length; i++) { randomChecksumData[i] = (byte)((testData[i] + 1) & 0x7f); } driver.doOnNext(ByteBuffer.wrap(randomChecksumData)); driver.doOnComplete(); assertTrue(s.hasCompleted()); assertFalse(s.isOnErrorCalled()); }
|
@Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
@Test public void checksumValidationFailure_throwsSdkClientException_NotNPE() { final byte[] incorrectData = new byte[0]; final TestPublisher driver = new TestPublisher(); final TestSubscriber s = new TestSubscriber(Arrays.copyOfRange(incorrectData, 0, TEST_DATA_SIZE)); final ChecksumValidatingPublisher p = new ChecksumValidatingPublisher(driver, new Md5Checksum(), TEST_DATA_SIZE + CHECKSUM_SIZE); p.subscribe(s); driver.doOnNext(ByteBuffer.wrap(incorrectData)); driver.doOnComplete(); assertTrue(s.isOnErrorCalled()); assertFalse(s.hasCompleted()); }
|
@Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> { @Override public void subscribe(Subscriber<? super ByteBuffer> s) { if (contentLength > 0) { publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, contentLength)); } else { publisher.subscribe(new ChecksumSkippingSubscriber(s)); } } ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
long contentLength); @Override void subscribe(Subscriber<? super ByteBuffer> s); }
|
@Test public void getObjectChecksumEnabledPerRequest_nonGetObjectRequestFalse() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectAclRequest.builder().build(), new ExecutionAttributes())).isFalse(); }
|
public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void getObjectChecksumEnabledPerRequest_defaultReturnTrue() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectRequest.builder().build(), new ExecutionAttributes())).isTrue(); }
|
public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void getObjectChecksumEnabledPerRequest_disabledPerConfig() { assertThat(getObjectChecksumEnabledPerRequest(GetObjectRequest.builder().build(), getExecutionAttributesWithChecksumDisabled())).isFalse(); }
|
public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerRequest(SdkRequest request, ExecutionAttributes executionAttributes) { return request instanceof GetObjectRequest && checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void getObjectChecksumEnabledPerResponse_nonGetObjectRequestFalse() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectAclRequest.builder().build(), getSdkHttpResponseWithChecksumHeader())).isFalse(); }
|
public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void getObjectChecksumEnabledPerResponse_responseContainsChecksumHeader_returnTrue() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectRequest.builder().build(), getSdkHttpResponseWithChecksumHeader())).isTrue(); }
|
public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void equalsAndHashCode_differentProperty_signedHeaders() { Map<String, List<String>> otherSignedHeaders = new HashMap<>(); otherSignedHeaders.put("fake-key", Collections.unmodifiableList(Arrays.asList("other-one", "other-two"))); PresignedGetObjectRequest request = generateMaximal(); PresignedGetObjectRequest otherRequest = request.toBuilder().signedHeaders(otherSignedHeaders).build(); assertThat(request).isNotEqualTo(otherRequest); assertThat(request.hashCode()).isNotEqualTo(otherRequest.hashCode()); }
|
@Override public Builder toBuilder() { return new DefaultBuilder(this); }
|
PresignedGetObjectRequest extends PresignedRequest implements ToCopyableBuilder<PresignedGetObjectRequest.Builder, PresignedGetObjectRequest> { @Override public Builder toBuilder() { return new DefaultBuilder(this); } }
|
PresignedGetObjectRequest extends PresignedRequest implements ToCopyableBuilder<PresignedGetObjectRequest.Builder, PresignedGetObjectRequest> { @Override public Builder toBuilder() { return new DefaultBuilder(this); } private PresignedGetObjectRequest(DefaultBuilder builder); }
|
PresignedGetObjectRequest extends PresignedRequest implements ToCopyableBuilder<PresignedGetObjectRequest.Builder, PresignedGetObjectRequest> { @Override public Builder toBuilder() { return new DefaultBuilder(this); } private PresignedGetObjectRequest(DefaultBuilder builder); static Builder builder(); @Override Builder toBuilder(); }
|
PresignedGetObjectRequest extends PresignedRequest implements ToCopyableBuilder<PresignedGetObjectRequest.Builder, PresignedGetObjectRequest> { @Override public Builder toBuilder() { return new DefaultBuilder(this); } private PresignedGetObjectRequest(DefaultBuilder builder); static Builder builder(); @Override Builder toBuilder(); }
|
@Test public void getObjectChecksumEnabledPerResponse_responseNotContainsChecksumHeader_returnFalse() { assertThat(getObjectChecksumEnabledPerResponse(GetObjectRequest.builder().build(), SdkHttpFullResponse.builder().build())).isFalse(); }
|
public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders) { return request instanceof GetObjectRequest && checksumEnabledPerResponse(responseHeaders); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_defaultShouldRecord() { assertThat(shouldRecordChecksum(PutObjectRequest.builder().build(), ClientType.SYNC, getSyncExecutionAttributes(), emptyHttpRequest().build())).isTrue(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_nonPutObjectRequest_false() { assertThat(shouldRecordChecksum(PutBucketAclRequest.builder().build(), ClientType.SYNC, getSyncExecutionAttributes(), emptyHttpRequest().build())).isFalse(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_disabledFromConfig_false() { ExecutionAttributes executionAttributes = getExecutionAttributesWithChecksumDisabled(); assertThat(shouldRecordChecksum(PutObjectRequest.builder().build(), ClientType.SYNC, executionAttributes, emptyHttpRequest().build())).isFalse(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_wrongClientType_false() { ExecutionAttributes executionAttributes = getSyncExecutionAttributes(); assertThat(shouldRecordChecksum(PutObjectRequest.builder().build(), ClientType.ASYNC, executionAttributes, emptyHttpRequest().build())).isFalse(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_serverSideCustomerEncryption_false() { ExecutionAttributes executionAttributes = getSyncExecutionAttributes(); SdkHttpRequest response = emptyHttpRequest().putHeader(SERVER_SIDE_CUSTOMER_ENCRYPTION_HEADER, "test") .build(); assertThat(shouldRecordChecksum(PutObjectRequest.builder().build(), ClientType.SYNC, executionAttributes, response)).isFalse(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void putObjectChecksumEnabled_serverSideEncryption_false() { ExecutionAttributes executionAttributes = getSyncExecutionAttributes(); SdkHttpRequest response = emptyHttpRequest().putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString()) .build(); assertThat(shouldRecordChecksum(PutObjectRequest.builder().build(), ClientType.SYNC, executionAttributes, response)).isFalse(); }
|
public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean shouldRecordChecksum(SdkRequest sdkRequest, ClientType expectedClientType, ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest) { if (!(sdkRequest instanceof PutObjectRequest)) { return false; } ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE); if (!expectedClientType.equals(actualClientType)) { return false; } if (hasServerSideEncryptionHeader(httpRequest)) { return false; } return checksumEnabledPerConfig(executionAttributes); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void responseChecksumIsValid_defaultTrue() { assertThat(responseChecksumIsValid(SdkHttpResponse.builder().build())).isTrue(); }
|
public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void responseChecksumIsValid_serverSideCustomerEncryption_false() { SdkHttpResponse response = SdkHttpResponse.builder() .putHeader(SERVER_SIDE_CUSTOMER_ENCRYPTION_HEADER, "test") .build(); assertThat(responseChecksumIsValid(response)).isFalse(); }
|
public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void responseChecksumIsValid_serverSideEncryption_false() { SdkHttpResponse response = SdkHttpResponse.builder() .putHeader(SERVER_SIDE_ENCRYPTION_HEADER, AWS_KMS.toString()) .build(); assertThat(responseChecksumIsValid(response)).isFalse(); }
|
public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); }
|
ChecksumsEnabledValidator { public static boolean responseChecksumIsValid(SdkHttpResponse httpResponse) { return !hasServerSideEncryptionHeader(httpResponse); } private ChecksumsEnabledValidator(); static boolean getObjectChecksumEnabledPerRequest(SdkRequest request,
ExecutionAttributes executionAttributes); static boolean getObjectChecksumEnabledPerResponse(SdkRequest request, SdkHttpHeaders responseHeaders); static boolean shouldRecordChecksum(SdkRequest sdkRequest,
ClientType expectedClientType,
ExecutionAttributes executionAttributes,
SdkHttpRequest httpRequest); static boolean responseChecksumIsValid(SdkHttpResponse httpResponse); static void validatePutObjectChecksum(PutObjectResponse response, ExecutionAttributes executionAttributes); static final ExecutionAttribute<SdkChecksum> CHECKSUM; }
|
@Test public void createMultipartRequest_shouldModifyHttpContent() { Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(CreateMultipartUploadRequest.builder().build()); Optional<RequestBody> requestBody = interceptor.modifyHttpContent(modifyHttpRequest, new ExecutionAttributes()); assertThat(modifyHttpRequest.requestBody().get()).isNotEqualTo(requestBody.get()); }
|
@Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void copySnapshotRequest_httpsProtocolAddedToEndpoint() { SdkHttpFullRequest request = SdkHttpFullRequest.builder() .uri(URI.create("https: .method(SdkHttpMethod.POST) .build(); CopySnapshotRequest ec2Request = CopySnapshotRequest.builder() .sourceRegion("us-west-2") .destinationRegion("us-east-2") .build(); when(mockContext.httpRequest()).thenReturn(request); when(mockContext.request()).thenReturn(ec2Request); ExecutionAttributes attrs = new ExecutionAttributes(); attrs.putAttribute(AWS_CREDENTIALS, AwsBasicCredentials.create("foo", "bar")); SdkHttpRequest modifiedRequest = INTERCEPTOR.modifyHttpRequest(mockContext, attrs); String presignedUrl = modifiedRequest.rawQueryParameters().get("PresignedUrl").get(0); assertThat(presignedUrl).startsWith("https: }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes); }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes); }
|
@Test public void copySnapshotRequest_generatesCorrectPresignedUrl() { String expectedPresignedUrl = "https: "&Version=2016-11-15" + "&DestinationRegion=us-east-1" + "&SourceRegion=us-west-2" + "&SourceSnapshotId=SNAPSHOT_ID" + "&X-Amz-Algorithm=AWS4-HMAC-SHA256" + "&X-Amz-Date=20200107T205609Z" + "&X-Amz-SignedHeaders=host" + "&X-Amz-Expires=604800" + "&X-Amz-Credential=akid%2F20200107%2Fus-west-2%2Fec2%2Faws4_request" + "&X-Amz-Signature=c1f5e34834292a86ff2b46b5e97cebaf2967b09641b4e2e60a382a37d137a03b"; ZoneId utcZone = ZoneId.of("UTC").normalized(); Instant signingInstant = ZonedDateTime.of(2020, 1, 7, 20, 56, 9, 0, utcZone).toInstant(); Clock signingClock = Clock.fixed(signingInstant, utcZone); GeneratePreSignUrlInterceptor interceptor = new GeneratePreSignUrlInterceptor(signingClock); SdkHttpFullRequest request = SdkHttpFullRequest.builder() .uri(URI.create("https: .method(SdkHttpMethod.POST) .build(); CopySnapshotRequest ec2Request = CopySnapshotRequest.builder() .sourceRegion("us-west-2") .destinationRegion("us-east-1") .sourceSnapshotId("SNAPSHOT_ID") .build(); when(mockContext.httpRequest()).thenReturn(request); when(mockContext.request()).thenReturn(ec2Request); ExecutionAttributes attrs = new ExecutionAttributes(); attrs.putAttribute(AWS_CREDENTIALS, AwsBasicCredentials.create("akid", "skid")); SdkHttpRequest modifiedRequest = interceptor.modifyHttpRequest(mockContext, attrs); String generatedPresignedUrl = modifiedRequest.rawQueryParameters().get("PresignedUrl").get(0); assertThat(generatedPresignedUrl).isEqualTo(expectedPresignedUrl); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes); }
|
GeneratePreSignUrlInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); SdkRequest originalRequest = context.request(); if (originalRequest instanceof CopySnapshotRequest) { CopySnapshotRequest originalCopySnapshotRequest = (CopySnapshotRequest) originalRequest; if (originalCopySnapshotRequest.presignedUrl() != null) { return request; } String serviceName = "ec2"; String sourceRegion = originalCopySnapshotRequest.sourceRegion(); String sourceSnapshotId = originalCopySnapshotRequest .sourceSnapshotId(); String destinationRegion = originalCopySnapshotRequest.destinationRegion(); if (destinationRegion == null) { destinationRegion = AwsHostNameUtils.parseSigningRegion(request.host(), serviceName) .orElseThrow(() -> new IllegalArgumentException("Could not determine region for " + request.host())) .id(); } URI endPointSource = createEndpoint(sourceRegion, serviceName); SdkHttpFullRequest requestForPresigning = generateRequestForPresigning( sourceSnapshotId, sourceRegion, destinationRegion) .toBuilder() .uri(endPointSource) .method(SdkHttpMethod.GET) .build(); Aws4Signer signer = Aws4Signer.create(); Aws4PresignerParams signingParams = getPresignerParams(executionAttributes, sourceRegion, serviceName); SdkHttpFullRequest presignedRequest = signer.presign(requestForPresigning, signingParams); return request.toBuilder() .putRawQueryParameter("DestinationRegion", destinationRegion) .putRawQueryParameter("PresignedUrl", presignedRequest.getUri().toString()) .build(); } return request; } GeneratePreSignUrlInterceptor(); @SdkTestInternalApi GeneratePreSignUrlInterceptor(Clock testClock); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes); }
|
@Test public void parseArn_outpostBucketArn() { S3Resource resource = ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("outpost/1234/bucket/myBucket") .build()); assertThat(resource, instanceOf(S3ControlBucketResource.class)); S3ControlBucketResource bucketResource = (S3ControlBucketResource) resource; assertThat(bucketResource.bucketName(), is("myBucket")); assertThat(bucketResource.parentS3Resource().get(), instanceOf(S3OutpostResource.class)); S3OutpostResource outpostResource = (S3OutpostResource) bucketResource.parentS3Resource().get(); assertThat(outpostResource.accountId(), is(Optional.of("123456789012"))); assertThat(outpostResource.partition(), is(Optional.of("aws"))); assertThat(outpostResource.region(), is(Optional.of("us-east-1"))); assertThat(outpostResource.type(), is(S3ControlResourceType.OUTPOST.toString())); assertThat(outpostResource.outpostId(), is("1234")); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_outpostAccessPointArn() { S3Resource resource = ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3-outposts") .region("us-east-1") .accountId("123456789012") .resource("outpost/1234/accesspoint/myAccessPoint") .build()); assertThat(resource, instanceOf(S3AccessPointResource.class)); S3AccessPointResource accessPointResource = (S3AccessPointResource) resource; assertThat(accessPointResource.accessPointName(), is("myAccessPoint")); assertThat(accessPointResource.parentS3Resource().get(), instanceOf(S3OutpostResource.class)); S3OutpostResource outpostResource = (S3OutpostResource) accessPointResource.parentS3Resource().get(); assertThat(outpostResource.outpostId(), is("1234")); assertThat(outpostResource.accountId(), is(Optional.of("123456789012"))); assertThat(outpostResource.partition(), is(Optional.of("aws"))); assertThat(outpostResource.region(), is(Optional.of("us-east-1"))); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_invalidOutpostAccessPointMissingAccessPointName_shouldThrowException() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Invalid format"); ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("outpost:op-01234567890123456:accesspoint") .build()); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_invalidOutpostAccessPointMissingOutpostId_shouldThrowException() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Invalid format"); ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("outpost/myaccesspoint") .build()); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_malformedOutpostArn_shouldThrowException() { exception.expect(IllegalArgumentException.class); exception.expectMessage("Unknown outpost ARN"); ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("outpost:1:accesspoin1:1") .build()); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_unknownResource() { exception.expect(IllegalArgumentException.class); exception.expectMessage("ARN type"); ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("unknown:foobar") .build()); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void parseArn_unknownType_throwsCorrectException() { exception.expect(IllegalArgumentException.class); exception.expectMessage("invalidType"); ARN_PARSER.convertArn(Arn.builder() .partition("aws") .service("s3") .region("us-east-1") .accountId("123456789012") .resource("invalidType:something") .build()); }
|
@Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
S3ControlArnConverter implements ArnConverter<S3Resource> { @Override public S3Resource convertArn(Arn arn) { S3ControlResourceType s3ResourceType; try { s3ResourceType = arn.resource().resourceType().map(S3ControlResourceType::fromValue) .orElseThrow(() -> new IllegalArgumentException("resource type cannot be null")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } switch (s3ResourceType) { case OUTPOST: return parseS3OutpostArn(arn); default: throw new IllegalArgumentException("Unknown ARN type '" + arn.resource().resourceType() + "'"); } } private S3ControlArnConverter(); static S3ControlArnConverter getInstance(); @Override S3Resource convertArn(Arn arn); }
|
@Test public void outpostBucketArn_shouldResolveHost() { Arn arn = Arn.fromString("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket"); SdkHttpRequest modifiedRequest = arnHandler.resolveHostForArn(request, configuration, arn, executionAttributes); assertThat(modifiedRequest.host(), is("s3-outposts.us-west-2.amazonaws.com")); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME), is("s3-outposts")); assertThat(modifiedRequest.headers().get("x-amz-outpost-id").get(0), is("op-01234567890123456")); assertThat(modifiedRequest.headers().get("x-amz-account-id").get(0), is(ACCOUNT_ID)); }
|
public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
@Test public void createMultipartRequest_shouldModifyHttpRequest() { Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(CreateMultipartUploadRequest.builder().build()); SdkHttpRequest httpRequest = interceptor.modifyHttpRequest(modifyHttpRequest, new ExecutionAttributes()); assertThat(httpRequest).isNotEqualTo(modifyHttpRequest.httpRequest()); assertThat(httpRequest.headers()).containsEntry(CONTENT_LENGTH, Collections.singletonList("0")); assertThat(httpRequest.headers()).containsEntry(CONTENT_TYPE, Collections.singletonList("binary/octet-stream")); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void outpostAccessPointArn_shouldResolveHost() { Arn arn = Arn.fromString("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"); SdkHttpRequest modifiedRequest = arnHandler.resolveHostForArn(request, configuration, arn, executionAttributes); assertThat(modifiedRequest.host(), is("s3-outposts.us-west-2.amazonaws.com")); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME), is("s3-outposts")); assertThat(modifiedRequest.headers().get("x-amz-outpost-id").get(0), is("op-01234567890123456")); assertThat(modifiedRequest.headers().get("x-amz-account-id").get(0), is(ACCOUNT_ID)); }
|
public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
@Test public void outpostArnWithFipsEnabled_shouldThrowException() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("FIPS"); Arn arn = Arn.fromString("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket"); arnHandler.resolveHostForArn(request, enableFips(), arn, executionAttributes); }
|
public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
@Test public void outpostArnWithDualstackEnabled_shouldThrowException() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Dualstack"); Arn arn = Arn.fromString("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket"); arnHandler.resolveHostForArn(request, enableDualstack(), arn, executionAttributes); }
|
public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
ArnHandler { public SdkHttpRequest resolveHostForArn(SdkHttpRequest request, S3ControlConfiguration configuration, Arn arn, ExecutionAttributes executionAttributes) { S3Resource s3Resource = S3ControlArnConverter.getInstance().convertArn(arn); String clientRegion = executionAttributes.getAttribute(SIGNING_REGION).id(); String originalArnRegion = s3Resource.region().orElseThrow(() -> new IllegalArgumentException("Region is missing")); boolean isFipsEnabled = isFipsEnabledInClientConfig(configuration) || isFipsRegionProvided(clientRegion, originalArnRegion, useArnRegion(configuration)); String arnRegion = removeFipsIfNeeded(originalArnRegion); validateConfiguration(executionAttributes, arn.partition(), arnRegion, configuration); executionAttributes.putAttribute(SIGNING_REGION, Region.of(arnRegion)); S3Resource parentS3Resource = s3Resource.parentS3Resource().orElse(null); if (parentS3Resource instanceof S3OutpostResource) { return handleOutpostArn(request, (S3OutpostResource) parentS3Resource, isFipsEnabled, configuration, executionAttributes); } else { throw new IllegalArgumentException("Parent resource invalid, outpost resource expected."); } } private ArnHandler(); static ArnHandler getInstance(); SdkHttpRequest resolveHostForArn(SdkHttpRequest request,
S3ControlConfiguration configuration,
Arn arn,
ExecutionAttributes executionAttributes); }
|
@Test public void modifyHttpRequest_ResolvesCorrectHost_StandardSettings() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request), new ExecutionAttributes()); assertThat(modified.host()).isEqualTo("s3-control.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void modifyHttpRequest_ResolvesCorrectHost_Dualstack() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().dualstackEnabled(true).build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request), executionAttributes); assertThat(modified.host()).isEqualTo("s3-control.dualstack.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void modifyHttpRequest_ResolvesCorrectHost_Fips() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().fipsModeEnabled(true).build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request), executionAttributes); assertThat(modified.host()).isEqualTo("s3-control-fips.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void createBucketRequestWithOutpostId_shouldRedirect() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); CreateBucketRequest createBucketRequest = CreateBucketRequest.builder().outpostId("1234").build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request).request(createBucketRequest), executionAttributes); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME)).isEqualTo("s3-outposts"); assertThat(modified.host()).isEqualTo("s3-outposts.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void listRegionalBucketsRequestsWithOutpostId_shouldRedirect() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); ListRegionalBucketsRequest sdkRequest = ListRegionalBucketsRequest.builder().outpostId("1234").build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); executionAttributes.putAttribute(SERVICE_SIGNING_NAME, "s3"); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request).request(sdkRequest), executionAttributes); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME)).isEqualTo("s3-outposts"); assertThat(modified.host()).isEqualTo("s3-outposts.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void listRegionalBucketsRequestsWithoutOutpostId_shouldNotRedirect() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); ListRegionalBucketsRequest sdkRequest = ListRegionalBucketsRequest.builder().build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder() .dualstackEnabled(true) .build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); executionAttributes.putAttribute(SERVICE_SIGNING_NAME, "s3"); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request).request(sdkRequest), executionAttributes); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME)).isEqualTo("s3"); assertThat(modified.host()).isEqualTo("s3-control.dualstack.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void createBucketRequestsWithoutOutpostId_shouldNotRedirect() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); ListRegionalBucketsRequest sdkRequest = ListRegionalBucketsRequest.builder() .build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder() .fipsModeEnabled(true) .build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); executionAttributes.putAttribute(SERVICE_SIGNING_NAME, "s3"); SdkHttpRequest modified = interceptor.modifyHttpRequest(new Context(request).request(sdkRequest), executionAttributes); assertThat(executionAttributes.getAttribute(SERVICE_SIGNING_NAME)).isEqualTo("s3"); assertThat(modified.host()).isEqualTo("s3-control-fips.us-east-1.amazonaws.com"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void createMultipartRequest_contentTypePresent_shouldNotModifyContentType() { String overrideContentType = "application/json"; Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(CreateMultipartUploadRequest.builder().build(), sdkHttpFullRequest().toBuilder() .putHeader(CONTENT_TYPE, overrideContentType).build()); SdkHttpRequest httpRequest = interceptor.modifyHttpRequest(modifyHttpRequest, new ExecutionAttributes()); assertThat(httpRequest).isNotEqualTo(modifyHttpRequest.httpRequest()); assertThat(httpRequest.headers()).containsEntry(CONTENT_LENGTH, Collections.singletonList("0")); assertThat(httpRequest.headers()).containsEntry(CONTENT_TYPE, Collections.singletonList(overrideContentType)); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { SdkHttpRequest.Builder builder = context.httpRequest() .toBuilder() .putHeader(CONTENT_LENGTH, String.valueOf(0)); if (!context.httpRequest().firstMatchingHeader(CONTENT_TYPE).isPresent()) { builder.putHeader(CONTENT_TYPE, "binary/octet-stream"); } return builder.build(); } return context.httpRequest(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void listRegionalBucketsRequestWithOutpostId_fipsEnabled_shouldThrowException() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); ListRegionalBucketsRequest sdkRequest = ListRegionalBucketsRequest.builder() .outpostId("123") .build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().fipsModeEnabled(true).build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); executionAttributes.putAttribute(SERVICE_SIGNING_NAME, "s3"); assertThatThrownBy(() -> interceptor.modifyHttpRequest(new Context(request).request(sdkRequest), executionAttributes)).hasMessageContaining("FIPS endpoints are " + "not supported"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void listRegionalBucketsRequestWithOutpostId_fipsDualsackEnabled_shouldThrowException() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); ListRegionalBucketsRequest sdkRequest = ListRegionalBucketsRequest.builder() .outpostId("123") .build(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder().dualstackEnabled(true).build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); executionAttributes.putAttribute(SIGNING_REGION, Region.US_EAST_1); executionAttributes.putAttribute(SERVICE_SIGNING_NAME, "s3"); assertThatThrownBy(() -> interceptor.modifyHttpRequest(new Context(request).request(sdkRequest), executionAttributes)).hasMessageContaining("Dualstack endpoints are " + "not supported"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test(expected = SdkClientException.class) public void modifyHttpRequest_ThrowsException_FipsAndDualstack() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder() .fipsModeEnabled(true) .dualstackEnabled(true) .build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); interceptor.modifyHttpRequest(new Context(request), executionAttributes); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test(expected = SdkClientException.class) public void modifyHttpRequest_ThrowsException_NonStandardEndpoint() { EndpointAddressInterceptor interceptor = new EndpointAddressInterceptor(); S3ControlConfiguration controlConfiguration = S3ControlConfiguration.builder() .dualstackEnabled(true) .build(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); executionAttributes.putAttribute(SdkExecutionAttribute.SERVICE_CONFIG, controlConfiguration); interceptor.modifyHttpRequest(new Context(request.toBuilder().host("some-garbage").build()), executionAttributes); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
EndpointAddressInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest request = context.httpRequest(); S3ControlConfiguration config = (S3ControlConfiguration) executionAttributes.getAttribute( AwsSignerExecutionAttribute.SERVICE_CONFIG); S3ArnableField arnableField = executionAttributes.getAttribute(S3_ARNABLE_FIELD); if (arnableField != null && arnableField.arn() != null) { return arnHandler.resolveHostForArn(request, config, arnableField.arn(), executionAttributes); } String host; if (isNonArnOutpostRequest(context.request())) { host = resolveHostForNonArnOutpostRequest(config, executionAttributes); } else { host = resolveHost(request, config); } return request.toBuilder() .host(host) .build(); } EndpointAddressInterceptor(); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void modifyHttpContent_AddsExecutionAttributeAndPayload() { PayloadSigningInterceptor interceptor = new PayloadSigningInterceptor(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); Optional<RequestBody> modified = interceptor.modifyHttpContent(new Context(request, null), executionAttributes); assertThat(modified.isPresent()).isTrue(); assertThat(modified.get().contentLength()).isEqualTo(0); assertThat(executionAttributes.getAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING)).isTrue(); }
|
public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void modifyHttpContent_DoesNotReplaceBody() { PayloadSigningInterceptor interceptor = new PayloadSigningInterceptor(); ExecutionAttributes executionAttributes = new ExecutionAttributes(); Optional<RequestBody> modified = interceptor.modifyHttpContent(new Context(request, RequestBody.fromString("hello")), executionAttributes); assertThat(modified.isPresent()).isTrue(); assertThat(modified.get().contentLength()).isEqualTo(5); assertThat(executionAttributes.getAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING)).isTrue(); }
|
public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
PayloadSigningInterceptor implements ExecutionInterceptor { public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { executionAttributes.putAttribute(S3SignerExecutionAttribute.ENABLE_PAYLOAD_SIGNING, true); if (!context.requestBody().isPresent() && context.httpRequest().method().equals(SdkHttpMethod.POST)) { return Optional.of(RequestBody.fromBytes(new byte[0])); } return context.requestBody(); } Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void doesNotClobberExistingValue() { SdkHttpRequest request = newRequest("some-value"); Mockito.when(ctx.httpRequest()).thenReturn(request); request = interceptor.modifyHttpRequest(ctx, new ExecutionAttributes()); assertThat(request.headers().get("Accept")).containsOnly("some-value"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void addsStandardAcceptHeaderIfMissing() { SdkHttpRequest request = newRequest(null); Mockito.when(ctx.httpRequest()).thenReturn(request); request = interceptor.modifyHttpRequest(ctx, new ExecutionAttributes()); assertThat(request.headers().get("Accept")).containsOnly("application/json"); }
|
@Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
AcceptJsonInterceptor implements ExecutionInterceptor { @Override public SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { SdkHttpRequest httpRequest = context.httpRequest(); if (!httpRequest.headers().containsKey("Accept")) { return httpRequest .toBuilder() .putHeader("Accept", "application/json") .build(); } return httpRequest; } @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void usEast1_AwsPartition_IsValidRegion() { assertTrue(RegionValidationUtil.validRegion("us-east-1", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void usWest2Fips_AwsPartition_IsValidRegion() { assertTrue(RegionValidationUtil.validRegion("us-west-2-fips", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void nonCreateMultipartRequest_shouldNotModifyHttpContent() { Context.ModifyHttpRequest modifyHttpRequest = InterceptorTestUtils.modifyHttpRequestContext(PutObjectRequest.builder().build()); Optional<RequestBody> requestBody = interceptor.modifyHttpContent(modifyHttpRequest, new ExecutionAttributes()); assertThat(modifyHttpRequest.requestBody().get()).isEqualTo(requestBody.get()); }
|
@Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
CreateMultipartUploadRequestInterceptor implements ExecutionInterceptor { @Override public Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context, ExecutionAttributes executionAttributes) { if (context.request() instanceof CreateMultipartUploadRequest) { return Optional.of(RequestBody.fromInputStream(new ByteArrayInputStream(new byte[0]), 0)); } return context.requestBody(); } @Override Optional<RequestBody> modifyHttpContent(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); @Override SdkHttpRequest modifyHttpRequest(Context.ModifyHttpRequest context,
ExecutionAttributes executionAttributes); }
|
@Test public void fipsUsWest2_AwsPartition_IsNotValidRegion() { assertTrue(RegionValidationUtil.validRegion("fips-us-west-2", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void fips_AwsPartition_IsNotValidRegion() { assertFalse(RegionValidationUtil.validRegion("fips", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void prodFips_AwsPartition_IsNotValidRegion() { assertFalse(RegionValidationUtil.validRegion("ProdFips", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void cnNorth1_AwsCnPartition_IsNotValidRegion() { assertFalse(RegionValidationUtil.validRegion("cn-north-1", AWS_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void cnNorth1_AwsCnPartition_IsValidRegion() { assertTrue(RegionValidationUtil.validRegion("cn-north-1", AWS_CN_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
@Test public void usEast1_AwsCnPartition_IsNotValidRegion() { assertFalse(RegionValidationUtil.validRegion("us-east-1", AWS_CN_PARTITION_REGEX)); }
|
public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
RegionValidationUtil { public static boolean validRegion(String region, String regex) { return matchesRegex(region, regex) || matchesRegexFipsSuffix(region, regex) || matchesRegexFipsPrefix(region, regex) || isGlobal(region); } private RegionValidationUtil(); static boolean validRegion(String region, String regex); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.