Don't explode grants from the DB (#5104)
This removes the Cartesian product in the DB for GrantsForUser in favor of returning the actual grant scope information and dealing with it in application code. (cherry picked from commit 913cd536823d73994acc4f4d833208c1cc05f91b)
This commit is contained in:
1 parent
2945692bf4
commit
62d4f8453b
38 files changed
+3663
-1645
No files matched your search
@@ -273,6 +273,7 @@ func Verify(ctx context.Context, opt ...Option) (ret VerifyResults) {
|
||||
Id: opts.withId,
|
||||
Pin: opts.withPin,
|
||||
Type: opts.withType,
|
||||
// Parent Scope ID will be filled in via performAuthCheck
|
||||
}
|
||||
// Global scope has no parent ID; account for this
|
||||
if opts.withId == scope.Global.String() && opts.withType == resource.Scope {
|
||||
@@ -336,7 +337,7 @@ func Verify(ctx context.Context, opt ...Option) (ret VerifyResults) {
|
||||
grants = append(grants, event.Grant{
|
||||
Grant: g.Grant,
|
||||
RoleId: g.RoleId,
|
||||
ScopeId: g.ScopeId,
|
||||
ScopeId: g.GrantScopeId,
|
||||
})
|
||||
}
|
||||
ea.UserInfo = &event.UserInfo{
|
||||
@@ -636,6 +637,7 @@ func (v verifier) performAuthCheck(ctx context.Context) (
|
||||
ParentScopeId: scp.GetParentId(),
|
||||
}
|
||||
}
|
||||
v.res.ParentScopeId = scopeInfo.ParentScopeId
|
||||
|
||||
// At this point we don't need to look up grants since it's automatically allowed
|
||||
if v.requestInfo.TokenFormat == uint32(AuthTokenTypeRecoveryKms) {
|
||||
@@ -658,7 +660,7 @@ func (v verifier) performAuthCheck(ctx context.Context) (
|
||||
// Note: Below, we always skip validation so that we don't error on formats
|
||||
// that we've since restricted, e.g. "ids=foo;actions=create,read". These
|
||||
// will simply not have an effect.
|
||||
for _, pair := range grantTuples {
|
||||
for _, tuple := range grantTuples {
|
||||
permsOpts := []perms.Option{
|
||||
perms.WithUserId(*userData.User.Id),
|
||||
perms.WithSkipFinalValidation(true),
|
||||
@@ -668,11 +670,10 @@ func (v verifier) performAuthCheck(ctx context.Context) (
|
||||
}
|
||||
parsed, err := perms.Parse(
|
||||
ctx,
|
||||
pair.ScopeId,
|
||||
pair.Grant,
|
||||
tuple,
|
||||
permsOpts...)
|
||||
if err != nil {
|
||||
retErr = errors.Wrap(ctx, err, op, errors.WithMsg(fmt.Sprintf("failed to parse grant %#v", pair.Grant)))
|
||||
retErr = errors.Wrap(ctx, err, op, errors.WithMsg(fmt.Sprintf("failed to parse grant %#v", tuple.Grant)))
|
||||
return
|
||||
}
|
||||
parsedGrants = append(parsedGrants, parsed)
|
||||
@@ -867,7 +868,7 @@ func (r *VerifyResults) ScopesAuthorizedForList(ctx context.Context, rootScopeId
|
||||
aSet := r.FetchActionSetForType(ctx,
|
||||
resource.Unknown, // This is overridden by `WithResource` option.
|
||||
action.NewActionSet(action.List),
|
||||
WithResource(&perms.Resource{Type: resourceType, ScopeId: scpId}),
|
||||
WithResource(&perms.Resource{Type: resourceType, ScopeId: scpId, ParentScopeId: scp.GetParentId()}),
|
||||
)
|
||||
|
||||
// We only expect the action set to be nothing, or list. In case
|
||||
|
||||
@@ -9,6 +9,7 @@ import (
|
||||
"github.com/hashicorp/boundary/internal/perms"
|
||||
"github.com/hashicorp/boundary/internal/types/action"
|
||||
"github.com/hashicorp/boundary/internal/types/resource"
|
||||
"github.com/hashicorp/boundary/sdk/pbs/controller/api/resources/scopes"
|
||||
"github.com/hashicorp/go-secure-stdlib/strutil"
|
||||
"google.golang.org/protobuf/types/known/structpb"
|
||||
)
|
||||
@@ -22,11 +23,12 @@ import (
|
||||
func CalculateAuthorizedCollectionActions(ctx context.Context,
|
||||
authResults VerifyResults,
|
||||
mapToRange map[resource.Type]action.ActionSet,
|
||||
scopeId, pin string,
|
||||
scopeInfo *scopes.ScopeInfo, pin string,
|
||||
) (map[string]*structpb.ListValue, error) {
|
||||
res := &perms.Resource{
|
||||
ScopeId: scopeId,
|
||||
Pin: pin,
|
||||
ScopeId: scopeInfo.GetId(),
|
||||
Pin: pin,
|
||||
ParentScopeId: scopeInfo.GetParentScopeId(),
|
||||
}
|
||||
// Range over the defined collections and check permissions against those
|
||||
// collections.
|
||||
|
||||
@@ -4385,3 +4385,118 @@ func TestChangePassword(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// The purpose of this test is mainly to ensure that we are properly fetching
|
||||
// membership information in GrantsForUser across managed group types
|
||||
func TestGrantsAcrossManagedGroups(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
conn, _ := db.TestSetup(t, "postgres")
|
||||
rw := db.New(conn)
|
||||
wrap := db.TestWrapper(t)
|
||||
kmsCache := kms.TestKms(t, conn, wrap)
|
||||
|
||||
org, _ := iam.TestScopes(t, iam.TestRepo(t, conn, wrap))
|
||||
|
||||
databaseWrapper, err := kmsCache.GetWrapper(ctx, org.PublicId, kms.KeyPurposeDatabase)
|
||||
require.NoError(t, err)
|
||||
oidcAm := oidc.TestAuthMethod(
|
||||
t, conn, databaseWrapper, org.PublicId, oidc.ActivePrivateState,
|
||||
"alice-rp", "fido",
|
||||
oidc.WithIssuer(oidc.TestConvertToUrls(t, "https://www.alice.com")[0]),
|
||||
oidc.WithSigningAlgs(oidc.RS256),
|
||||
oidc.WithApiUrl(oidc.TestConvertToUrls(t, "https://www.alice.com/callback")[0]),
|
||||
)
|
||||
oidcAcct := oidc.TestAccount(t, conn, oidcAm, "test-subject")
|
||||
// Create a managed group that will always match, so we can test that it is
|
||||
// returned in results
|
||||
oidcMg := oidc.TestManagedGroup(t, conn, oidcAm, `"/token/sub" matches ".*"`)
|
||||
oidc.TestManagedGroupMember(t, conn, oidcMg.GetPublicId(), oidcAcct.GetPublicId())
|
||||
|
||||
ldapAm := ldap.TestAuthMethod(t, conn, databaseWrapper, org.PublicId, []string{"ldaps://ldap1"})
|
||||
ldapAcct := ldap.TestAccount(t, conn, ldapAm, "test-acct",
|
||||
ldap.WithMemberOfGroups(ctx, "admin"),
|
||||
ldap.WithFullName(ctx, "test-name"),
|
||||
ldap.WithEmail(ctx, "test-email"),
|
||||
ldap.WithDn(ctx, "test-dn"),
|
||||
)
|
||||
ldapMg := ldap.TestManagedGroup(t, conn, ldapAm, []string{"admin"})
|
||||
|
||||
iamRepoFn := func() (*iam.Repository, error) {
|
||||
return iam.NewRepository(ctx, rw, rw, kmsCache)
|
||||
}
|
||||
iamRepo, err := iamRepoFn()
|
||||
require.NoError(t, err)
|
||||
|
||||
user := iam.TestUser(t, iamRepo, org.PublicId, iam.WithAccountIds(oidcAcct.GetPublicId(), ldapAcct.GetPublicId()))
|
||||
|
||||
// Create two roles, each containing a single managed group, and add a
|
||||
// unique grant to each
|
||||
oidcRole := iam.TestRole(t, conn, org.GetPublicId(), iam.WithGrantScopeIds([]string{globals.GrantScopeChildren}))
|
||||
iam.TestManagedGroupRole(t, conn, oidcRole.GetPublicId(), oidcMg.GetPublicId())
|
||||
iam.TestRoleGrant(t, conn, oidcRole.GetPublicId(), "ids=ttcp_oidc;actions=read")
|
||||
ldapRole := iam.TestRole(t, conn, org.GetPublicId(), iam.WithGrantScopeIds([]string{globals.GrantScopeChildren}))
|
||||
iam.TestManagedGroupRole(t, conn, ldapRole.GetPublicId(), ldapMg.GetPublicId())
|
||||
iam.TestRoleGrant(t, conn, ldapRole.GetPublicId(), "ids=ttcp_ldap;actions=read")
|
||||
|
||||
grants, err := iamRepo.GrantsForUser(ctx, user.GetPublicId())
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify we see both grants
|
||||
var foundOidc, foundLdap bool
|
||||
for _, grant := range grants {
|
||||
if grant.Grant == "ids=ttcp_oidc;actions=read" {
|
||||
foundOidc = true
|
||||
}
|
||||
if grant.Grant == "ids=ttcp_ldap;actions=read" {
|
||||
foundLdap = true
|
||||
}
|
||||
}
|
||||
assert.True(t, foundOidc)
|
||||
assert.True(t, foundLdap)
|
||||
|
||||
// Delete the ldap managed group
|
||||
ldapRepo, err := ldap.NewRepository(ctx, rw, rw, kmsCache)
|
||||
require.NoError(t, err)
|
||||
numDeleted, err := ldapRepo.DeleteManagedGroup(ctx, org.GetPublicId(), ldapMg.GetPublicId())
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, 1, numDeleted)
|
||||
|
||||
// Verify we don't see the ldap grant anymore
|
||||
grants, err = iamRepo.GrantsForUser(ctx, user.GetPublicId())
|
||||
require.NoError(t, err)
|
||||
foundOidc = false
|
||||
foundLdap = false
|
||||
for _, grant := range grants {
|
||||
if grant.Grant == "ids=ttcp_oidc;actions=read" {
|
||||
foundOidc = true
|
||||
}
|
||||
if grant.Grant == "ids=ttcp_ldap;actions=read" {
|
||||
foundLdap = true
|
||||
}
|
||||
}
|
||||
assert.True(t, foundOidc)
|
||||
assert.False(t, foundLdap)
|
||||
|
||||
// Delete the oidc managed group
|
||||
oidcRepo, err := oidc.NewRepository(ctx, rw, rw, kmsCache)
|
||||
require.NoError(t, err)
|
||||
numDeleted, err = oidcRepo.DeleteManagedGroup(ctx, org.GetPublicId(), oidcMg.GetPublicId())
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, 1, numDeleted)
|
||||
|
||||
// Verify we don't see the oidc grant anymore
|
||||
grants, err = iamRepo.GrantsForUser(ctx, user.GetPublicId())
|
||||
require.NoError(t, err)
|
||||
foundOidc = false
|
||||
foundLdap = false
|
||||
for _, grant := range grants {
|
||||
if grant.Grant == "ids=ttcp_oidc;actions=read" {
|
||||
foundOidc = true
|
||||
}
|
||||
if grant.Grant == "ids=ttcp_ldap;actions=read" {
|
||||
foundLdap = true
|
||||
}
|
||||
}
|
||||
assert.False(t, foundOidc)
|
||||
assert.False(t, foundLdap)
|
||||
}
|
||||
@@ -343,7 +343,7 @@ func (s Service) GetAuthMethod(ctx context.Context, req *pbs.GetAuthMethodReques
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, am.GetPublicId(), IdActions[globals.ResourceInfoFromPrefix(am.GetPublicId()).Subtype]).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope.Id, am.GetPublicId())
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope, am.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -388,7 +388,7 @@ func (s Service) CreateAuthMethod(ctx context.Context, req *pbs.CreateAuthMethod
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, am.GetPublicId(), IdActions[globals.ResourceInfoFromPrefix(am.GetPublicId()).Subtype]).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope.Id, am.GetPublicId())
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope, am.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -438,7 +438,7 @@ func (s Service) UpdateAuthMethod(ctx context.Context, req *pbs.UpdateAuthMethod
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, am.GetPublicId(), IdActions[globals.ResourceInfoFromPrefix(am.GetPublicId()).Subtype]).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope.Id, am.GetPublicId())
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope, am.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -492,7 +492,7 @@ func (s Service) ChangeState(ctx context.Context, req *pbs.ChangeStateRequest) (
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, am.GetPublicId(), IdActions[globals.ResourceInfoFromPrefix(am.GetPublicId()).Subtype]).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope.Id, am.GetPublicId())
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope, am.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -1442,6 +1442,10 @@ func (s Service) convertToAuthenticateResponse(ctx context.Context, req *pbs.Aut
|
||||
ScopeId: authResults.Scope.Id,
|
||||
Type: resource.AuthToken,
|
||||
}
|
||||
// Auth methods are only at global or org, so we can figure out the parent
|
||||
if strings.HasPrefix(res.ScopeId, scope.Org.Prefix()) {
|
||||
res.ParentScopeId = scope.Global.String()
|
||||
}
|
||||
tokenType := req.GetType()
|
||||
if tokenType == "" {
|
||||
// Fall back to deprecated field if type is not set
|
||||
@@ -1588,7 +1592,7 @@ func newOutputOpts(ctx context.Context, item auth.AuthMethod, scopeInfoMap map[s
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authorizedActions))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope.Id, item.GetPublicId())
|
||||
collectionActions, err := requestauth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap, authResults.Scope, item.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
|
||||
@@ -996,10 +996,10 @@ func calculateAuthorizedCollectionActions(ctx context.Context, authResults auth.
|
||||
var err error
|
||||
switch globals.ResourceInfoFromPrefix(id).Subtype {
|
||||
case vault.Subtype:
|
||||
collectionActions, err = auth.CalculateAuthorizedCollectionActions(ctx, authResults, vaultCollectionTypeMap, authResults.Scope.Id, id)
|
||||
collectionActions, err = auth.CalculateAuthorizedCollectionActions(ctx, authResults, vaultCollectionTypeMap, authResults.Scope, id)
|
||||
|
||||
case static.Subtype:
|
||||
collectionActions, err = auth.CalculateAuthorizedCollectionActions(ctx, authResults, staticCollectionTypeMap, authResults.Scope.Id, id)
|
||||
collectionActions, err = auth.CalculateAuthorizedCollectionActions(ctx, authResults, staticCollectionTypeMap, authResults.Scope, id)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
||||
@@ -342,7 +342,7 @@ func (s Service) GetHostCatalog(ctx context.Context, req *pbs.GetHostCatalogRequ
|
||||
subtype = hostplugin.Subtype
|
||||
}
|
||||
if subtype != "" {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope.Id, hc.GetPublicId())
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope, hc.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -399,7 +399,7 @@ func (s Service) CreateHostCatalog(ctx context.Context, req *pbs.CreateHostCatal
|
||||
subtype = hostplugin.Subtype
|
||||
}
|
||||
if subtype != "" {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope.Id, hc.GetPublicId())
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope, hc.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -462,7 +462,7 @@ func (s Service) UpdateHostCatalog(ctx context.Context, req *pbs.UpdateHostCatal
|
||||
subtype = hostplugin.Subtype
|
||||
}
|
||||
if subtype != "" {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope.Id, hc.GetPublicId())
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope, hc.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -795,7 +795,7 @@ func newOutputOpts(
|
||||
subtype = hostplugin.Subtype
|
||||
}
|
||||
if subtype != "" {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope.Id, item.GetPublicId())
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, collectionTypeMap[subtype], authResults.Scope, item.GetPublicId())
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
|
||||
@@ -1123,7 +1123,7 @@ func toProto(ctx context.Context, in *iam.Role, principals []*iam.PrincipalRole,
|
||||
}
|
||||
if outputFields.Has(globals.GrantsField) {
|
||||
for _, g := range grants {
|
||||
parsed, err := perms.Parse(ctx, in.GetScopeId(), g.GetRawGrant())
|
||||
parsed, err := perms.Parse(ctx, perms.GrantTuple{RoleScopeId: in.GetPublicId(), GrantScopeId: in.GetScopeId(), Grant: g.GetRawGrant()})
|
||||
if err != nil {
|
||||
// This should never happen as we validate on the way in, but let's
|
||||
// return what we can since we are still returning the raw grant
|
||||
@@ -1319,7 +1319,7 @@ func validateAddRoleGrantsRequest(ctx context.Context, req *pbs.AddRoleGrantsReq
|
||||
badFields["grant_strings"] = "Grant strings must not be empty."
|
||||
break
|
||||
}
|
||||
grant, err := perms.Parse(ctx, "p_anything", v)
|
||||
grant, err := perms.Parse(ctx, perms.GrantTuple{RoleScopeId: req.GetId(), GrantScopeId: "p_anything", Grant: v})
|
||||
if err != nil {
|
||||
badFields["grant_strings"] = fmt.Sprintf("Improperly formatted grant %q.", v)
|
||||
break
|
||||
@@ -1356,9 +1356,9 @@ func validateSetRoleGrantsRequest(ctx context.Context, req *pbs.SetRoleGrantsReq
|
||||
badFields["grant_strings"] = "Grant strings must not be empty."
|
||||
break
|
||||
}
|
||||
grant, err := perms.Parse(ctx, "p_anything", v)
|
||||
grant, err := perms.Parse(ctx, perms.GrantTuple{RoleScopeId: req.GetId(), GrantScopeId: "p_anything", Grant: v})
|
||||
if err != nil {
|
||||
badFields["grant_strings"] = fmt.Sprintf("Improperly formatted grant %q.", v)
|
||||
badFields["grant_strings"] = fmt.Sprintf("Improperly formatted grant %q: %s.", v, err.Error())
|
||||
break
|
||||
}
|
||||
_, actStrs := grant.Actions()
|
||||
@@ -1396,7 +1396,7 @@ func validateRemoveRoleGrantsRequest(ctx context.Context, req *pbs.RemoveRoleGra
|
||||
badFields["grant_strings"] = "Grant strings must not be empty."
|
||||
break
|
||||
}
|
||||
if _, err := perms.Parse(ctx, "p_anything", v); err != nil {
|
||||
if _, err := perms.Parse(ctx, perms.GrantTuple{RoleScopeId: req.GetId(), GrantScopeId: "p_anything", Grant: v}); err != nil {
|
||||
badFields["grant_strings"] = fmt.Sprintf("Improperly formatted grant %q.", v)
|
||||
break
|
||||
}
|
||||
|
||||
@@ -1026,7 +1026,7 @@ func TestCreate(t *testing.T) {
|
||||
func TestUpdate(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
grantString := "ids=*;type=*;actions=*"
|
||||
g, err := perms.Parse(context.Background(), "global", grantString)
|
||||
g, err := perms.Parse(context.Background(), perms.GrantTuple{RoleScopeId: "global", GrantScopeId: "global", Grant: grantString})
|
||||
require.NoError(t, err)
|
||||
_, actions := g.Actions()
|
||||
grant := &pb.Grant{
|
||||
@@ -2127,7 +2127,7 @@ func checkEqualGrants(t *testing.T, expected []string, got *pb.Role) {
|
||||
return got.GrantStrings[i] < got.GrantStrings[j]
|
||||
})
|
||||
for i, v := range expected {
|
||||
parsed, err := perms.Parse(context.Background(), "o_abc123", v)
|
||||
parsed, err := perms.Parse(context.Background(), perms.GrantTuple{RoleScopeId: "o_abc123", GrantScopeId: "o_abc123", Grant: v})
|
||||
require.NoError(err)
|
||||
assert.Equal(expected[i], got.GrantStrings[i])
|
||||
assert.Equal(expected[i], got.Grants[i].GetRaw())
|
||||
|
||||
@@ -337,7 +337,14 @@ func (s *Service) GetScope(ctx context.Context, req *pbs.GetScopeRequest) (*pbs.
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, p.GetPublicId(), idActionsById(p.GetPublicId())).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], p.GetPublicId(), "")
|
||||
scopeInfo := &pb.ScopeInfo{
|
||||
Id: p.GetPublicId(),
|
||||
Type: p.Type,
|
||||
Name: p.GetName(),
|
||||
Description: p.GetDescription(),
|
||||
ParentScopeId: p.GetParentId(),
|
||||
}
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], scopeInfo, "")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -382,7 +389,14 @@ func (s *Service) CreateScope(ctx context.Context, req *pbs.CreateScopeRequest)
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, p.GetPublicId(), idActionsById(p.GetPublicId())).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], p.GetPublicId(), "")
|
||||
scopeInfo := &pb.ScopeInfo{
|
||||
Id: p.GetPublicId(),
|
||||
Type: p.Type,
|
||||
Name: p.GetName(),
|
||||
Description: p.GetDescription(),
|
||||
ParentScopeId: p.GetParentId(),
|
||||
}
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], scopeInfo, "")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -427,7 +441,14 @@ func (s *Service) UpdateScope(ctx context.Context, req *pbs.UpdateScopeRequest)
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authResults.FetchActionSetForId(ctx, p.GetPublicId(), idActionsById(p.GetPublicId())).Strings()))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], p.GetPublicId(), "")
|
||||
scopeInfo := &pb.ScopeInfo{
|
||||
Id: p.GetPublicId(),
|
||||
Type: p.Type,
|
||||
Name: p.GetName(),
|
||||
Description: p.GetDescription(),
|
||||
ParentScopeId: p.GetParentId(),
|
||||
}
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[p.Type], scopeInfo, "")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -1137,7 +1158,14 @@ func newOutputOpts(ctx context.Context, item *iam.Scope, authResults auth.Verify
|
||||
outputOpts = append(outputOpts, handlers.WithAuthorizedActions(authorizedActions))
|
||||
}
|
||||
if outputFields.Has(globals.AuthorizedCollectionActionsField) {
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[item.Type], item.GetPublicId(), "")
|
||||
scopeInfo := &pb.ScopeInfo{
|
||||
Id: item.GetPublicId(),
|
||||
Type: item.Type,
|
||||
Name: item.GetName(),
|
||||
Description: item.GetDescription(),
|
||||
ParentScopeId: item.GetParentId(),
|
||||
}
|
||||
collectionActions, err := auth.CalculateAuthorizedCollectionActions(ctx, authResults, scopeCollectionTypeMapMap[item.Type], scopeInfo, "")
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
|
||||
@@ -575,9 +575,10 @@ func validateCancelRequest(req *pbs.CancelSessionRequest) error {
|
||||
|
||||
func newOutputOpts(ctx context.Context, item *session.Session, scopeIds map[string]*scopes.ScopeInfo, authResults auth.VerifyResults) ([]handlers.Option, bool) {
|
||||
res := perms.Resource{
|
||||
Type: resource.Session,
|
||||
Id: item.GetPublicId(),
|
||||
ScopeId: item.GetProjectId(),
|
||||
Type: resource.Session,
|
||||
Id: item.GetPublicId(),
|
||||
ScopeId: item.GetProjectId(),
|
||||
ParentScopeId: scopeIds[item.ProjectId].ParentScopeId,
|
||||
}
|
||||
authorizedActions := authResults.FetchActionSetForId(ctx, item.GetPublicId(), IdActions, auth.WithResource(&res)).Strings()
|
||||
if len(authorizedActions) == 0 {
|
||||
|
||||
@@ -2006,7 +2006,7 @@ func validateListRequest(ctx context.Context, req *pbs.ListTargetsRequest) error
|
||||
}
|
||||
|
||||
func newOutputOpts(ctx context.Context, item target.Target, authResults auth.VerifyResults, authzScopes map[string]*scopes.ScopeInfo) []handlers.Option {
|
||||
pr := perms.Resource{Id: item.GetPublicId(), ScopeId: item.GetProjectId(), Type: resource.Target}
|
||||
pr := perms.Resource{Id: item.GetPublicId(), ScopeId: item.GetProjectId(), Type: resource.Target, ParentScopeId: authzScopes[item.GetProjectId()].GetParentScopeId()}
|
||||
outputFields := authResults.FetchOutputFields(pr, action.List).SelfOrDefaults(authResults.UserId)
|
||||
|
||||
outputOpts := make([]handlers.Option, 0, 3)
|
||||
|
||||
@@ -489,13 +489,8 @@ func TestList(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestListPagination(t *testing.T) {
|
||||
// Set database read timeout to avoid duplicates in response
|
||||
oldReadTimeout := globals.RefreshReadLookbackDuration
|
||||
globals.RefreshReadLookbackDuration = 0
|
||||
t.Cleanup(func() {
|
||||
globals.RefreshReadLookbackDuration = oldReadTimeout
|
||||
})
|
||||
func TestListGrantScopes(t *testing.T) {
|
||||
t.Parallel()
|
||||
ctx := context.Background()
|
||||
conn, _ := db.TestSetup(t, "postgres")
|
||||
sqlDB, err := conn.SqlDB(ctx)
|
||||
@@ -515,27 +510,395 @@ func TestListPagination(t *testing.T) {
|
||||
serversRepoFn := func() (*server.Repository, error) {
|
||||
return server.NewRepository(ctx, rw, rw, kms)
|
||||
}
|
||||
repo, err := target.NewRepository(ctx, rw, rw, kms)
|
||||
|
||||
at := authtoken.TestAuthToken(t, conn, kms, scope.Global.String())
|
||||
|
||||
var projects []*iam.Scope
|
||||
org1, proj1 := iam.TestScopes(t, iamRepo)
|
||||
projects = append(projects, proj1)
|
||||
org2, proj2 := iam.TestScopes(t, iamRepo)
|
||||
projects = append(projects, proj2)
|
||||
|
||||
var totalTars []*pb.Target
|
||||
for i, proj := range projects {
|
||||
for j := 0; j < 5; j++ {
|
||||
name := fmt.Sprintf("tar-%d-%d", i, j)
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj.GetPublicId(), name, target.WithAddress(fmt.Sprintf("1.1.%d.%d", i, j)))
|
||||
totalTars = append(totalTars, &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj.GetPublicId(),
|
||||
Name: wrapperspb.String(name),
|
||||
Scope: &scopes.ScopeInfo{Id: proj.GetPublicId(), Type: scope.Project.String(), ParentScopeId: proj.ParentId},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
Type: tcp.Subtype.String(),
|
||||
Attrs: &pb.Target_TcpTargetAttributes{},
|
||||
SessionMaxSeconds: wrapperspb.UInt32(28800),
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{Value: fmt.Sprintf("1.1.%d.%d", i, j)},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Run analyze to update postgres estimates
|
||||
_, err = sqlDB.ExecContext(ctx, "analyze")
|
||||
require.NoError(t, err)
|
||||
|
||||
org, proj := iam.TestScopes(t, iamRepo)
|
||||
at := authtoken.TestAuthToken(t, conn, kms, org.GetPublicId())
|
||||
r := iam.TestRole(t, conn, proj.GetPublicId())
|
||||
_ = iam.TestUserRole(t, conn, r.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, r.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
hc := static.TestCatalogs(t, conn, proj.GetPublicId(), 1)[0]
|
||||
hss := static.TestSets(t, conn, hc.GetPublicId(), 2)
|
||||
s, err := testService(t, context.Background(), conn, kms, wrapper)
|
||||
require.NoError(t, err)
|
||||
_ = org1
|
||||
_ = org2
|
||||
|
||||
var allTargets []*pb.Target
|
||||
for i := 0; i < 10; i++ {
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj.GetPublicId(), fmt.Sprintf("tar%d", i), target.WithHostSources([]string{hss[0].GetPublicId(), hss[1].GetPublicId()}))
|
||||
allTargets = append(allTargets, &pb.Target{
|
||||
cases := []struct {
|
||||
name string
|
||||
pageSize uint32
|
||||
setupFunc func(t *testing.T)
|
||||
res *pbs.ListTargetsResponse
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "global-with-direct-grants-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
globalRole := iam.TestRole(t, conn, scope.Global.String(), iam.WithGrantScopeIds([]string{proj1.GetPublicId(), proj2.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, globalRole.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, globalRole.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: totalTars,
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 10,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "global-with-direct-grants-non-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
globalRole := iam.TestRole(t, conn, scope.Global.String(), iam.WithGrantScopeIds([]string{proj1.GetPublicId(), proj2.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, globalRole.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, globalRole.GetPublicId(), "ids=*;type=target;actions=list")
|
||||
_ = iam.TestRoleGrant(t, conn, globalRole.GetPublicId(), fmt.Sprintf("ids=%s,%s;actions=*", totalTars[0].Id, totalTars[1].Id))
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: totalTars[0:2],
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 2,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "global-with-descendants-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
globalRole := iam.TestRole(t, conn, scope.Global.String(), iam.WithGrantScopeIds([]string{globals.GrantScopeDescendants}))
|
||||
_ = iam.TestUserRole(t, conn, globalRole.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, globalRole.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: totalTars,
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 10,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "org-with-direct-grants-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
org1Role := iam.TestRole(t, conn, org1.GetPublicId(), iam.WithGrantScopeIds([]string{proj1.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, org1Role.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, org1Role.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
org2Role := iam.TestRole(t, conn, org2.GetPublicId(), iam.WithGrantScopeIds([]string{proj2.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, org2Role.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, org2Role.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: totalTars,
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 10,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "org-with-direct-grants-non-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
org1Role := iam.TestRole(t, conn, org1.GetPublicId(), iam.WithGrantScopeIds([]string{proj1.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, org1Role.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, org1Role.GetPublicId(), "ids=*;type=target;actions=list")
|
||||
_ = iam.TestRoleGrant(t, conn, org1Role.GetPublicId(), fmt.Sprintf("ids=%s,%s;actions=*", totalTars[0].Id, totalTars[1].Id))
|
||||
org2Role := iam.TestRole(t, conn, org2.GetPublicId(), iam.WithGrantScopeIds([]string{proj2.GetPublicId()}))
|
||||
_ = iam.TestUserRole(t, conn, org2Role.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, org2Role.GetPublicId(), "ids=*;type=target;actions=list")
|
||||
_ = iam.TestRoleGrant(t, conn, org2Role.GetPublicId(), fmt.Sprintf("ids=%s,%s;actions=*", totalTars[5].Id, totalTars[6].Id))
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: append([]*pb.Target{}, append(append([]*pb.Target{}, totalTars[0:2]...), totalTars[5:7]...)...),
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 4,
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "org-with-children-wildcard",
|
||||
setupFunc: func(t *testing.T) {
|
||||
org1Role := iam.TestRole(t, conn, org1.GetPublicId(), iam.WithGrantScopeIds([]string{globals.GrantScopeChildren}))
|
||||
_ = iam.TestUserRole(t, conn, org1Role.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, org1Role.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
},
|
||||
res: &pbs.ListTargetsResponse{
|
||||
Items: totalTars[0:5],
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
EstItemCount: 5,
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
assert, require := assert.New(t), require.New(t)
|
||||
_, err := sqlDB.Exec("delete from iam_role")
|
||||
require.NoError(err)
|
||||
tc.setupFunc(t)
|
||||
|
||||
s, err := testService(t, context.Background(), conn, kms, wrapper)
|
||||
require.NoError(err, "Couldn't create new target service.")
|
||||
|
||||
requestInfo := authpb.RequestInfo{
|
||||
TokenFormat: uint32(auth.AuthTokenTypeBearer),
|
||||
PublicId: at.GetPublicId(),
|
||||
Token: at.GetToken(),
|
||||
}
|
||||
requestContext := context.WithValue(context.Background(), requests.ContextRequestInformationKey, &requests.RequestContext{})
|
||||
ctx := auth.NewVerifierContext(requestContext, iamRepoFn, tokenRepoFn, serversRepoFn, kms, &requestInfo)
|
||||
got, gErr := s.ListTargets(ctx, &pbs.ListTargetsRequest{
|
||||
ScopeId: scope.Global.String(),
|
||||
Recursive: true,
|
||||
PageSize: tc.pageSize,
|
||||
})
|
||||
if tc.err != nil {
|
||||
require.Error(gErr)
|
||||
assert.True(errors.Is(gErr, tc.err), "got error %v, wanted %v", gErr, tc.err)
|
||||
return
|
||||
}
|
||||
require.NoError(gErr)
|
||||
assert.Equal(len(tc.res.Items), len(got.Items))
|
||||
wantById := make(map[string]*pb.Target, len(tc.res.Items))
|
||||
for _, t := range tc.res.Items {
|
||||
wantById[t.Id] = t
|
||||
}
|
||||
for _, t := range got.Items {
|
||||
want, ok := wantById[t.Id]
|
||||
assert.True(ok, "Got unexpected target with id: %s", t.Id)
|
||||
assert.Empty(cmp.Diff(
|
||||
t,
|
||||
want,
|
||||
protocmp.Transform(),
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
), "got %v, wanted %v", t, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListPagination(t *testing.T) {
|
||||
testListPagination := func(t *testing.T, useDescendants bool) {
|
||||
// Set database read timeout to avoid duplicates in response
|
||||
oldReadTimeout := globals.RefreshReadLookbackDuration
|
||||
globals.RefreshReadLookbackDuration = 0
|
||||
t.Cleanup(func() {
|
||||
globals.RefreshReadLookbackDuration = oldReadTimeout
|
||||
})
|
||||
ctx := context.Background()
|
||||
conn, _ := db.TestSetup(t, "postgres")
|
||||
sqlDB, err := conn.SqlDB(ctx)
|
||||
require.NoError(t, err)
|
||||
wrapper := db.TestWrapper(t)
|
||||
kms := kms.TestKms(t, conn, wrapper)
|
||||
|
||||
rw := db.New(conn)
|
||||
|
||||
iamRepo := iam.TestRepo(t, conn, wrapper)
|
||||
iamRepoFn := func() (*iam.Repository, error) {
|
||||
return iamRepo, nil
|
||||
}
|
||||
tokenRepoFn := func() (*authtoken.Repository, error) {
|
||||
return authtoken.NewRepository(ctx, rw, rw, kms)
|
||||
}
|
||||
serversRepoFn := func() (*server.Repository, error) {
|
||||
return server.NewRepository(ctx, rw, rw, kms)
|
||||
}
|
||||
repo, err := target.NewRepository(ctx, rw, rw, kms)
|
||||
require.NoError(t, err)
|
||||
|
||||
// We're going to run the same test in two projects; one with
|
||||
// descendants and one with direct grants in one project and a child
|
||||
// grant from org in another project
|
||||
org1, proj1 := iam.TestScopes(t, iamRepo)
|
||||
org2, proj2 := iam.TestScopes(t, iamRepo)
|
||||
at := authtoken.TestAuthToken(t, conn, kms, scope.Global.String())
|
||||
if useDescendants {
|
||||
r := iam.TestRole(t, conn, scope.Global.String(), iam.WithGrantScopeIds([]string{globals.GrantScopeDescendants}))
|
||||
_ = iam.TestUserRole(t, conn, r.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, r.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
} else {
|
||||
r1 := iam.TestRole(t, conn, proj1.GetPublicId())
|
||||
_ = iam.TestUserRole(t, conn, r1.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, r1.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
r2 := iam.TestRole(t, conn, org2.GetPublicId(), iam.WithGrantScopeIds([]string{globals.GrantScopeChildren}))
|
||||
_ = iam.TestUserRole(t, conn, r2.GetPublicId(), at.GetIamUserId())
|
||||
_ = iam.TestRoleGrant(t, conn, r2.GetPublicId(), "ids=*;type=*;actions=*")
|
||||
}
|
||||
hc := static.TestCatalogs(t, conn, proj1.GetPublicId(), 1)[0]
|
||||
hss := static.TestSets(t, conn, hc.GetPublicId(), 2)
|
||||
s, err := testService(t, context.Background(), conn, kms, wrapper)
|
||||
require.NoError(t, err)
|
||||
|
||||
var allTargets []*pb.Target
|
||||
for i := 0; i < 10; i++ {
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj1.GetPublicId(), fmt.Sprintf("tar-1-%d", i), target.WithHostSources([]string{hss[0].GetPublicId(), hss[1].GetPublicId()}))
|
||||
allTargets = append(allTargets, &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj1.GetPublicId(),
|
||||
Name: wrapperspb.String(tar.GetName()),
|
||||
Scope: &scopes.ScopeInfo{Id: proj1.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org1.GetPublicId()},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
Type: tcp.Subtype.String(),
|
||||
Attrs: &pb.Target_TcpTargetAttributes{},
|
||||
SessionMaxSeconds: wrapperspb.UInt32(28800),
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{},
|
||||
})
|
||||
}
|
||||
for i := 0; i < 10; i++ {
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj2.GetPublicId(), fmt.Sprintf("tar-2-%d", i), target.WithAddress(fmt.Sprintf("127.0.0.%d", i)))
|
||||
allTargets = append(allTargets, &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj2.GetPublicId(),
|
||||
Name: wrapperspb.String(tar.GetName()),
|
||||
Scope: &scopes.ScopeInfo{Id: proj2.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org2.GetPublicId()},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
Type: tcp.Subtype.String(),
|
||||
Attrs: &pb.Target_TcpTargetAttributes{},
|
||||
SessionMaxSeconds: wrapperspb.UInt32(28800),
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{Value: fmt.Sprintf("127.0.0.%d", i)},
|
||||
})
|
||||
}
|
||||
// Reverse since we read items in descending order (newest first)
|
||||
slices.Reverse(allTargets)
|
||||
|
||||
// Run analyze to update postgres estimates
|
||||
_, err = sqlDB.ExecContext(ctx, "analyze")
|
||||
require.NoError(t, err)
|
||||
|
||||
requestInfo := authpb.RequestInfo{
|
||||
TokenFormat: uint32(auth.AuthTokenTypeBearer),
|
||||
PublicId: at.GetPublicId(),
|
||||
Token: at.GetToken(),
|
||||
}
|
||||
requestContext := context.WithValue(context.Background(), requests.ContextRequestInformationKey, &requests.RequestContext{})
|
||||
ctx = auth.NewVerifierContext(requestContext, iamRepoFn, tokenRepoFn, serversRepoFn, kms, &requestInfo)
|
||||
|
||||
// Start paginating, recursively
|
||||
req := &pbs.ListTargetsRequest{
|
||||
ScopeId: "global",
|
||||
Recursive: true,
|
||||
Filter: "",
|
||||
ListToken: "",
|
||||
PageSize: 2,
|
||||
}
|
||||
got, err := s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[0:2],
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request second page
|
||||
req.ListToken = got.ListToken
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[2:4],
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request rest of results
|
||||
req.ListToken = got.ListToken
|
||||
req.PageSize = 20
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 16)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[4:],
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Create another target
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj1.GetPublicId(), "test-target-1", target.WithHostSources([]string{hss[0].GetPublicId(), hss[1].GetPublicId()}))
|
||||
newTarget := &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj.GetPublicId(),
|
||||
ScopeId: proj1.GetPublicId(),
|
||||
Name: wrapperspb.String(tar.GetName()),
|
||||
Scope: &scopes.ScopeInfo{Id: proj.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org.GetPublicId()},
|
||||
Scope: &scopes.ScopeInfo{Id: proj1.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org1.GetPublicId()},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
@@ -545,285 +908,230 @@ func TestListPagination(t *testing.T) {
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{},
|
||||
}
|
||||
// Add to the front since it's most recently updated
|
||||
allTargets = append([]*pb.Target{newTarget}, allTargets...)
|
||||
tar = tcp.TestTarget(ctx, t, conn, proj2.GetPublicId(), "test-target-2", target.WithAddress(fmt.Sprintf("127.0.0.11")))
|
||||
newTarget = &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj2.GetPublicId(),
|
||||
Name: wrapperspb.String(tar.GetName()),
|
||||
Scope: &scopes.ScopeInfo{Id: proj2.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org2.GetPublicId()},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
Type: tcp.Subtype.String(),
|
||||
Attrs: &pb.Target_TcpTargetAttributes{},
|
||||
SessionMaxSeconds: wrapperspb.UInt32(28800),
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{Value: fmt.Sprintf("127.0.0.11")},
|
||||
}
|
||||
allTargets = append([]*pb.Target{newTarget}, allTargets...)
|
||||
|
||||
// Leaving this function here as it is very useful if test objects change
|
||||
/*
|
||||
printNames := func(step string, tars []*pb.Target) {
|
||||
names := make([]string, len(tars))
|
||||
for i, t := range tars {
|
||||
names[i] = t.GetName().GetValue()
|
||||
}
|
||||
log.Println(step, pretty.Sprint(strings.Join(names, ", ")))
|
||||
}
|
||||
*/
|
||||
|
||||
// printNames("before delete ", allTargets)
|
||||
|
||||
// Delete one of the other targets in each project
|
||||
_, err = repo.DeleteTarget(ctx, allTargets[len(allTargets)-11].Id)
|
||||
require.NoError(t, err)
|
||||
deletedTarget1 := allTargets[len(allTargets)-11]
|
||||
allTargets = append(allTargets[:len(allTargets)-11], allTargets[len(allTargets)-11+1:]...)
|
||||
// printNames("after first delete ", allTargets)
|
||||
|
||||
_, err = repo.DeleteTarget(ctx, allTargets[len(allTargets)-1].Id)
|
||||
require.NoError(t, err)
|
||||
deletedTarget2 := allTargets[len(allTargets)-1]
|
||||
allTargets = allTargets[:len(allTargets)-1]
|
||||
// printNames("after second delete", allTargets)
|
||||
|
||||
// Update two of the other targets
|
||||
allTargets[2].Name = wrapperspb.String("new-name-1")
|
||||
allTargets[2].Version = 2
|
||||
updatedTarget := &tcp.Target{
|
||||
Target: &store.Target{
|
||||
PublicId: allTargets[2].Id,
|
||||
Name: allTargets[2].Name.GetValue(),
|
||||
ProjectId: allTargets[2].ScopeId,
|
||||
},
|
||||
}
|
||||
tg, _, err := repo.UpdateTarget(ctx, updatedTarget, 1, []string{"name"})
|
||||
require.NoError(t, err)
|
||||
allTargets[2].UpdatedTime = tg.GetUpdateTime().GetTimestamp()
|
||||
allTargets[2].Version = tg.GetVersion()
|
||||
// Add to the front since it's most recently updated
|
||||
newAllTargets := append([]*pb.Target{allTargets[2]}, allTargets[0:2]...)
|
||||
newAllTargets = append(newAllTargets, allTargets[3:]...)
|
||||
allTargets = newAllTargets
|
||||
// printNames("after first update ", allTargets)
|
||||
allTargets[11].Name = wrapperspb.String("new-name-11")
|
||||
allTargets[11].Version = 2
|
||||
updatedTarget = &tcp.Target{
|
||||
Target: &store.Target{
|
||||
PublicId: allTargets[11].Id,
|
||||
Name: allTargets[11].Name.GetValue(),
|
||||
ProjectId: allTargets[11].ScopeId,
|
||||
},
|
||||
}
|
||||
tg, _, err = repo.UpdateTarget(ctx, updatedTarget, 1, []string{"name"})
|
||||
require.NoError(t, err)
|
||||
allTargets[11].UpdatedTime = tg.GetUpdateTime().GetTimestamp()
|
||||
allTargets[11].Version = tg.GetVersion()
|
||||
// Add to the front since it's most recently updated
|
||||
newAllTargets = append([]*pb.Target{allTargets[11]}, allTargets[0:11]...)
|
||||
newAllTargets = append(newAllTargets, allTargets[12:]...)
|
||||
allTargets = newAllTargets
|
||||
// printNames("after second update", allTargets)
|
||||
|
||||
// Run analyze to update postgres estimates
|
||||
_, err = sqlDB.ExecContext(ctx, "analyze")
|
||||
require.NoError(t, err)
|
||||
|
||||
// Request updated results
|
||||
req.ListToken = got.ListToken
|
||||
req.PageSize = 2
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[0], allTargets[1]},
|
||||
ResponseType: "delta",
|
||||
SortBy: "updated_time",
|
||||
SortDir: "desc",
|
||||
// Should contain the deleted target
|
||||
RemovedIds: []string{deletedTarget1.Id, deletedTarget2.Id},
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Get next page
|
||||
req.ListToken = got.ListToken
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[2], allTargets[3]},
|
||||
ResponseType: "complete",
|
||||
SortBy: "updated_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request new page with filter requiring looping
|
||||
// to fill the page.
|
||||
req.ListToken = ""
|
||||
req.PageSize = 1
|
||||
req.Filter = fmt.Sprintf(`"/item/id"==%q or "/item/id"==%q`, allTargets[len(allTargets)-2].Id, allTargets[len(allTargets)-1].Id)
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[len(allTargets)-2]},
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
// Should be empty again
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
req.ListToken = got.ListToken
|
||||
// Get the second page
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[len(allTargets)-1]},
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 20,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Create unauthenticated user
|
||||
unauthAt := authtoken.TestAuthToken(t, conn, kms, org1.GetPublicId())
|
||||
unauthR := iam.TestRole(t, conn, proj1.GetPublicId())
|
||||
_ = iam.TestUserRole(t, conn, unauthR.GetPublicId(), unauthAt.GetIamUserId())
|
||||
|
||||
// Make a request with the unauthenticated user,
|
||||
// ensure the response contains the pagination parameters.
|
||||
requestInfo = authpb.RequestInfo{
|
||||
TokenFormat: uint32(auth.AuthTokenTypeBearer),
|
||||
PublicId: unauthAt.GetPublicId(),
|
||||
Token: unauthAt.GetToken(),
|
||||
}
|
||||
requestContext = context.WithValue(context.Background(), requests.ContextRequestInformationKey, &requests.RequestContext{})
|
||||
ctx = auth.NewVerifierContext(requestContext, iamRepoFn, tokenRepoFn, serversRepoFn, kms, &requestInfo)
|
||||
|
||||
got, err = s.ListTargets(ctx, &pbs.ListTargetsRequest{
|
||||
ScopeId: "global",
|
||||
Recursive: true,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, got.Items)
|
||||
assert.Equal(t, "created_time", got.SortBy)
|
||||
assert.Equal(t, "desc", got.SortDir)
|
||||
assert.Equal(t, "complete", got.ResponseType)
|
||||
}
|
||||
// Reverse since we read items in descending order (newest first)
|
||||
slices.Reverse(allTargets)
|
||||
|
||||
// Run analyze to update postgres estimates
|
||||
_, err = sqlDB.ExecContext(ctx, "analyze")
|
||||
require.NoError(t, err)
|
||||
|
||||
requestInfo := authpb.RequestInfo{
|
||||
TokenFormat: uint32(auth.AuthTokenTypeBearer),
|
||||
PublicId: at.GetPublicId(),
|
||||
Token: at.GetToken(),
|
||||
}
|
||||
requestContext := context.WithValue(context.Background(), requests.ContextRequestInformationKey, &requests.RequestContext{})
|
||||
ctx = auth.NewVerifierContext(requestContext, iamRepoFn, tokenRepoFn, serversRepoFn, kms, &requestInfo)
|
||||
|
||||
// Start paginating, recursively
|
||||
req := &pbs.ListTargetsRequest{
|
||||
ScopeId: "global",
|
||||
Recursive: true,
|
||||
Filter: "",
|
||||
ListToken: "",
|
||||
PageSize: 2,
|
||||
}
|
||||
got, err := s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[0:2],
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request second page
|
||||
req.ListToken = got.ListToken
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 2)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[2:4],
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request rest of results
|
||||
req.ListToken = got.ListToken
|
||||
req.PageSize = 10
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 6)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: allTargets[4:],
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Create another target
|
||||
tar := tcp.TestTarget(ctx, t, conn, proj.GetPublicId(), "test-target", target.WithHostSources([]string{hss[0].GetPublicId(), hss[1].GetPublicId()}))
|
||||
newTarget := &pb.Target{
|
||||
Id: tar.GetPublicId(),
|
||||
ScopeId: proj.GetPublicId(),
|
||||
Name: wrapperspb.String(tar.GetName()),
|
||||
Scope: &scopes.ScopeInfo{Id: proj.GetPublicId(), Type: scope.Project.String(), ParentScopeId: org.GetPublicId()},
|
||||
CreatedTime: tar.GetCreateTime().GetTimestamp(),
|
||||
UpdatedTime: tar.GetUpdateTime().GetTimestamp(),
|
||||
Version: tar.GetVersion(),
|
||||
Type: tcp.Subtype.String(),
|
||||
Attrs: &pb.Target_TcpTargetAttributes{},
|
||||
SessionMaxSeconds: wrapperspb.UInt32(28800),
|
||||
SessionConnectionLimit: wrapperspb.Int32(-1),
|
||||
AuthorizedActions: testAuthorizedActions,
|
||||
Address: &wrapperspb.StringValue{},
|
||||
}
|
||||
// Add to the front since it's most recently updated
|
||||
allTargets = append([]*pb.Target{newTarget}, allTargets...)
|
||||
|
||||
// Delete one of the other targets
|
||||
_, err = repo.DeleteTarget(ctx, allTargets[len(allTargets)-1].Id)
|
||||
require.NoError(t, err)
|
||||
deletedTarget := allTargets[len(allTargets)-1]
|
||||
allTargets = allTargets[:len(allTargets)-1]
|
||||
|
||||
// Update one of the other targets
|
||||
allTargets[1].Name = wrapperspb.String("new-name")
|
||||
allTargets[1].Version = 2
|
||||
updatedTarget := &tcp.Target{
|
||||
Target: &store.Target{
|
||||
PublicId: allTargets[1].Id,
|
||||
Name: allTargets[1].Name.GetValue(),
|
||||
ProjectId: allTargets[1].ScopeId,
|
||||
},
|
||||
}
|
||||
tg, _, err := repo.UpdateTarget(ctx, updatedTarget, 1, []string{"name"})
|
||||
require.NoError(t, err)
|
||||
allTargets[1].UpdatedTime = tg.GetUpdateTime().GetTimestamp()
|
||||
allTargets[1].Version = tg.GetVersion()
|
||||
// Add to the front since it's most recently updated
|
||||
allTargets = append(
|
||||
[]*pb.Target{allTargets[1]},
|
||||
append(
|
||||
[]*pb.Target{allTargets[0]},
|
||||
allTargets[2:]...,
|
||||
)...,
|
||||
)
|
||||
|
||||
// Run analyze to update postgres estimates
|
||||
_, err = sqlDB.ExecContext(ctx, "analyze")
|
||||
require.NoError(t, err)
|
||||
|
||||
// Request updated results
|
||||
req.ListToken = got.ListToken
|
||||
req.PageSize = 1
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[0]},
|
||||
ResponseType: "delta",
|
||||
SortBy: "updated_time",
|
||||
SortDir: "desc",
|
||||
// Should contain the deleted target
|
||||
RemovedIds: []string{deletedTarget.Id},
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Get next page
|
||||
req.ListToken = got.ListToken
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
// Compare without comparing the list token
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[1]},
|
||||
ResponseType: "complete",
|
||||
SortBy: "updated_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Request new page with filter requiring looping
|
||||
// to fill the page.
|
||||
req.ListToken = ""
|
||||
req.PageSize = 1
|
||||
req.Filter = fmt.Sprintf(`"/item/id"==%q or "/item/id"==%q`, allTargets[len(allTargets)-2].Id, allTargets[len(allTargets)-1].Id)
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[len(allTargets)-2]},
|
||||
ResponseType: "delta",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
// Should be empty again
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
req.ListToken = got.ListToken
|
||||
// Get the second page
|
||||
got, err = s.ListTargets(ctx, req)
|
||||
require.NoError(t, err)
|
||||
require.Len(t, got.GetItems(), 1)
|
||||
assert.Empty(t,
|
||||
cmp.Diff(
|
||||
got,
|
||||
&pbs.ListTargetsResponse{
|
||||
Items: []*pb.Target{allTargets[len(allTargets)-1]},
|
||||
ResponseType: "complete",
|
||||
SortBy: "created_time",
|
||||
SortDir: "desc",
|
||||
RemovedIds: nil,
|
||||
EstItemCount: 10,
|
||||
},
|
||||
cmpopts.SortSlices(func(a, b string) bool {
|
||||
return a < b
|
||||
}),
|
||||
protocmp.Transform(),
|
||||
protocmp.IgnoreFields(&pbs.ListTargetsResponse{}, "list_token"),
|
||||
),
|
||||
)
|
||||
|
||||
// Create unauthenticated user
|
||||
unauthAt := authtoken.TestAuthToken(t, conn, kms, org.GetPublicId())
|
||||
unauthR := iam.TestRole(t, conn, proj.GetPublicId())
|
||||
_ = iam.TestUserRole(t, conn, unauthR.GetPublicId(), unauthAt.GetIamUserId())
|
||||
|
||||
// Make a request with the unauthenticated user,
|
||||
// ensure the response contains the pagination parameters.
|
||||
requestInfo = authpb.RequestInfo{
|
||||
TokenFormat: uint32(auth.AuthTokenTypeBearer),
|
||||
PublicId: unauthAt.GetPublicId(),
|
||||
Token: unauthAt.GetToken(),
|
||||
}
|
||||
requestContext = context.WithValue(context.Background(), requests.ContextRequestInformationKey, &requests.RequestContext{})
|
||||
ctx = auth.NewVerifierContext(requestContext, iamRepoFn, tokenRepoFn, serversRepoFn, kms, &requestInfo)
|
||||
|
||||
got, err = s.ListTargets(ctx, &pbs.ListTargetsRequest{
|
||||
ScopeId: "global",
|
||||
Recursive: true,
|
||||
t.Run("with-descendants", func(t *testing.T) {
|
||||
testListPagination(t, true)
|
||||
})
|
||||
t.Run("without-descendants", func(t *testing.T) {
|
||||
testListPagination(t, false)
|
||||
})
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, got.Items)
|
||||
assert.Equal(t, "created_time", got.SortBy)
|
||||
assert.Equal(t, "desc", got.SortDir)
|
||||
assert.Equal(t, "complete", got.ResponseType)
|
||||
}
|
||||
|
||||
func TestDelete(t *testing.T) {
|
||||
|
||||
@@ -506,7 +506,7 @@ func (s Service) ListResolvableAliases(ctx context.Context, req *pbs.ListResolva
|
||||
}
|
||||
}
|
||||
|
||||
permissions := acl.ListResolvablePermissions(resource.Target, targets.IdActions)
|
||||
permissions := acl.ListResolvableAliasesPermissions(resource.Target, targets.IdActions)
|
||||
|
||||
if len(permissions) == 0 {
|
||||
// if there are no permitted targets then there will be no aliases that
|
||||
@@ -615,15 +615,14 @@ func (s Service) aclAndGrantHashForUser(ctx context.Context, userId string) (per
|
||||
// Note: Below, we always skip validation so that we don't error on formats
|
||||
// that we've since restricted, e.g. "ids=foo;actions=create,read". These
|
||||
// will simply not have an effect.
|
||||
for _, pair := range grantTuples {
|
||||
for _, tuple := range grantTuples {
|
||||
permsOpts := []perms.Option{
|
||||
perms.WithUserId(userId),
|
||||
perms.WithSkipFinalValidation(true),
|
||||
}
|
||||
parsed, err := perms.Parse(
|
||||
ctx,
|
||||
pair.ScopeId,
|
||||
pair.Grant,
|
||||
tuple,
|
||||
permsOpts...)
|
||||
if err != nil {
|
||||
return perms.ACL{}, nil, errors.Wrap(ctx, err, op)
|
||||
|
||||
Reference in new issue
Block a user