public static DeferredResult<SecurityContext> getSecurityContextForCurrentUser(Service service) { Operation getSecurityContext = Operation.createGet(service, SessionService.SELF_LINK); return service.sendWithDeferredResult(getSecurityContext, SecurityContext.class); }
/** * Executes the given query task on a Cluster. * * @param service * The service executing the query task. * @param queryTask * The query task. * @param cluster * The cluster, the query runs against. * @param isLocal * If true, use local query task. If false, use query task. */ public static DeferredResult<QueryTask> startQueryTask( Service service, QueryTask queryTask, ServiceTypeCluster cluster, boolean isLocal) { Operation createQueryTaskOp = createQueryTaskOperation(service, queryTask, cluster, isLocal); return service.sendWithDeferredResult(createQueryTaskOp, QueryTask.class); }
private DeferredResult<Void> deleteRole(String roleLink) { Operation roleDeleteOp = Operation .createDelete(service, UriUtils.buildUriPath(RoleService.FACTORY_LINK, roleLink)); return service.sendWithDeferredResult(roleDeleteOp).thenAccept(ignore -> { }); }
public static DeferredResult<Principal> getPrincipal(Service service, String principalId) { Operation getPrincipalOp = Operation.createGet(service, UriUtils.buildUriPath( PrincipalService.SELF_LINK, encode(principalId))); return service.sendWithDeferredResult(getPrincipalOp, Principal.class); }
/** * Retrieves the list of members for the specified by document link user group. */ private static DeferredResult<List<UserState>> retrieveUserGroupMembers(Service service, String groupLink, URI referer) { if (groupLink == null || groupLink.isEmpty()) { return DeferredResult.completed(new ArrayList<>()); } Operation groupGet = Operation.createGet(service, groupLink).setReferer(referer); authorizeOperationIfProjectService(service, groupGet); return service.sendWithDeferredResult(groupGet, UserGroupState.class) .thenCompose(groupState -> retrieveUserStatesForGroup(service, groupState)); }
public static DeferredResult<AuthCredentialsServiceState> retrieveExternalToken(Service service, AuthorizationContext ctx) { return service.sendWithDeferredResult(Operation.createGet(buildSessionURI(service, ctx)), SessionState.class).thenApply(sessionState -> { AuthCredentialsServiceState creds = new AuthCredentialsServiceState(); creds.privateKey = sessionState.externalToken; return creds; }); } }
private DeferredResult<Void> deleteExtendedMemberRole(String projectId, String groupId) { String encodedGroupId = encode(groupId); String roleLink = UriUtils.buildUriPath(RoleService.FACTORY_LINK, AuthRole.PROJECT_MEMBER_EXTENDED.buildRoleWithSuffix(projectId, encodedGroupId)); String resourceGroupLink = UriUtils.buildUriPath(ResourceGroupService.FACTORY_LINK, AuthRole.PROJECT_MEMBER_EXTENDED.buildRoleWithSuffix(projectId, encodedGroupId)); Operation deleteRgOp = Operation.createDelete(service, resourceGroupLink); Operation deleteRoleOp = Operation.createDelete(service, roleLink); return service.sendWithDeferredResult(deleteRgOp) .thenCompose(ignore -> service.sendWithDeferredResult(deleteRoleOp)) .thenAccept(ignore -> { }); }
public static DeferredResult<Principal> getPrincipal(Service requestorService, Operation requestorOperation, String principalId) { Operation getOp = Operation.createGet(requestorService, UriUtils.buildUriPath(PrincipalService.SELF_LINK, encode(principalId))); requestorService.setAuthorizationContext(getOp, requestorOperation.getAuthorizationContext()); return requestorService.sendWithDeferredResult(getOp, Principal.class); }
private static DeferredResult<UserState> getUserState(Service requestorService, String principalId) { Operation getUserStateOp = Operation.createGet(requestorService, AuthUtil.buildUserServicePathFromPrincipalId(encode(principalId))); requestorService.setAuthorizationContext(getUserStateOp, requestorService.getSystemAuthorizationContext()); return requestorService.sendWithDeferredResult(getUserStateOp, UserState.class) .exceptionally((ex) -> { if (ex.getCause() instanceof ServiceNotFoundException) { return new UserState(); } return null; }); }
private static DeferredResult<List<String>> retrieveProjectRelatedDocumentLinks( Service service, String projectLink, String factoryLink) { Operation get = Operation.createGet(service, factoryLink) .setReferer(service.getUri()) .addRequestHeader(OperationUtil.PROJECT_ADMIRAL_HEADER, projectLink); authorizeOperationIfProjectService(service, get); return service.sendWithDeferredResult(get, ServiceDocumentQueryResult.class) .thenApply(result -> result.documentLinks); }
public static DeferredResult<String> getHarborUrl(Service service) { Operation getConfigProp = Operation.createGet(service, UriUtils.buildUriPath( ConfigurationFactoryService.SELF_LINK, Harbor.CONFIGURATION_URL_PROPERTY_NAME)); DeferredResult<String> result = new DeferredResult<>(); service.sendWithDeferredResult(getConfigProp, ConfigurationState.class) .thenAccept(state -> result.complete(state.value)) .exceptionally(ex -> { ex = (ex instanceof CompletionException) ? ex.getCause() : ex; if (ex instanceof ServiceNotFoundException) { result.complete(null); } else { result.fail(ex); } return null; }); return result; }
private static DeferredResult<Void> assignUserGroupToBasicUsers(Service service, UserGroupState state) { String userGroupId = Service.getId(state.documentSelfLink); RoleState basicUserRole = AuthUtil.buildBasicUsersRole(userGroupId, state.documentSelfLink); RoleState basicUserExtendedRole = AuthUtil.buildBasicUsersExtendedRole(userGroupId, state.documentSelfLink); Operation postRole = Operation.createPost(service, ServiceUriPaths.CORE_AUTHZ_ROLES) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(basicUserRole); Operation postExtendedRole = Operation.createPost(service, ServiceUriPaths.CORE_AUTHZ_ROLES) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(basicUserExtendedRole); addReplicationFactor(postRole); addReplicationFactor(postExtendedRole); return DeferredResult.allOf( service.sendWithDeferredResult(postRole), service.sendWithDeferredResult(postExtendedRole)); }
private static DeferredResult<UserState> createUser(Service service, String principalId) { UserState user = new UserState(); user.email = decode(principalId); user.documentSelfLink = encode(principalId); Operation postUser = Operation .createPost(service, AuthUtil.buildUserServicePathFromPrincipalId("")) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(user); addReplicationFactor(postUser); return service.sendWithDeferredResult(postUser, UserState.class); }
@Override public DeferredResult<Principal> deletePrincipal(Operation op, String principalId) { assertNotNullOrEmpty(principalId, "principalId"); Operation delete = Operation.createDelete(service, UriUtils.buildUriPath(LocalPrincipalFactoryService.SELF_LINK, encode(principalId))); service.setAuthorizationContext(delete, service.getSystemAuthorizationContext()); return service.sendWithDeferredResult(delete, LocalPrincipalState.class) .thenApply((s) -> fromLocalPrincipalToPrincipal(s)); }
@Override public DeferredResult<Principal> createPrincipal(Operation op, Principal principal) { LocalPrincipalState stateToCreate = fromPrincipalToLocalPrincipal(principal); stateToCreate.documentSelfLink = encode(principal.id); Operation post = Operation.createPost(service, LocalPrincipalFactoryService.SELF_LINK) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(stateToCreate); service.setAuthorizationContext(post, service.getSystemAuthorizationContext()); return service.sendWithDeferredResult(post, LocalPrincipalState.class) .thenApply((s) -> fromLocalPrincipalToPrincipal(s)); }
@Override public DeferredResult<Principal> updatePrincipal(Operation op, Principal principal) { LocalPrincipalState stateToPatch = fromPrincipalToLocalPrincipal(principal); Operation patch = Operation.createPatch(service, UriUtils.buildUriPath(LocalPrincipalFactoryService.SELF_LINK, encode(stateToPatch.id))) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(stateToPatch); service.setAuthorizationContext(patch, service.getSystemAuthorizationContext()); return service.sendWithDeferredResult(patch, LocalPrincipalState.class) .thenApply((s) -> fromLocalPrincipalToPrincipal(s)); }
private DeferredResult<Void> handleCloudAdminGroupAssignment(String principalId) { return PrincipalUtil.getOrCreateUserGroup(service, principalId) .thenCompose(userGroup -> { RoleState roleState = buildCloudAdminsRole(encode(principalId), userGroup.documentSelfLink); Operation createRoleOp = Operation .createPost(service, RoleService.FACTORY_LINK) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(roleState); addReplicationFactor(createRoleOp); return service.sendWithDeferredResult(createRoleOp, RoleState.class); }).thenAccept(ignore -> { }); } }
private static DeferredResult<UserGroupState> createUserGroup(Service service, String principalId) { String userGroupSelfLink = UriUtils .buildUriPath(UserGroupService.FACTORY_LINK, encode(principalId)); Query userGroupQuery = AuthUtil.buildQueryForUsers(userGroupSelfLink); UserGroupState userGroupState = UserGroupState.Builder.create() .withSelfLink(userGroupSelfLink) .withQuery(userGroupQuery) .build(); Operation postGroup = Operation.createPost(service, ServiceUriPaths.CORE_AUTHZ_USER_GROUPS) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE) .setBody(userGroupState); addReplicationFactor(postGroup); return service.sendWithDeferredResult(postGroup, UserGroupState.class); }
private DeferredResult<Boolean> tryLogin(String principalId, String password) { String auth = BasicAuthenticationUtils.constructBasicAuth(principalId, password); AuthenticationRequest body = new AuthenticationRequest(); body.requestType = AuthenticationRequestType.LOGIN; Operation login = Operation.createPost(service.getHost(), BasicAuthenticationService.SELF_LINK) .setReferer(service.getHost().getUri()) .setBody(body) .addRequestHeader(Operation.AUTHORIZATION_HEADER, auth); return service.sendWithDeferredResult(login) .thenApply(op -> new Pair<>(op, null)) .exceptionally(ex -> new Pair<>(null, ex)) .thenApply(pair -> { if (pair.right != null) { return false; } return true; }); }
@Override public DeferredResult<Principal> getPrincipal(Operation op, String principalId) { assertNotNullOrEmpty(principalId, "principalId"); Operation get = Operation.createGet(service, UriUtils.buildUriPath(LocalPrincipalFactoryService.SELF_LINK, encode(principalId))); service.setAuthorizationContext(get, service.getSystemAuthorizationContext()); return service.sendWithDeferredResult(get, LocalPrincipalState.class) .thenApply(s -> fromLocalPrincipalToPrincipal(s)) .thenApply(p -> new Pair<Principal, Set<String>>(p, null)) .thenCompose(pair -> getAllGroupsForPrincipal(op, principalId) .thenApply(groups -> new Pair<>(pair.left, groups))) .thenApply(pair -> { pair.left.groups = pair.right; return pair.left; }); }