Files
threshold/internal/servers/repository_test.go
T
Todd 2ecd550e27 Add fields to server_worker to be a boundary resource (#2083)
* Remove the server_id from session table, change it to worker_id on session_connection

This is step 1 in updating the worker table.  The worker is becoming a public resource so it must have
a public id.  We drop the server_id column on the session_connection table and add the worker_id column
so we can use the wt_public_key type.  Since db migrations are applied while the controller is offline,
it should be safe to assume all session connections are not in a running state, thus allowing us to null
out all the worker ids in the session_connection table.

For now we don't have very good enforcement of the wt_public_id contraints, since the id is currently
defined in the worker config, but this will soon change and the worker's id will be generated by the
controller.

* Updating server_id references to controller_id.

* Adding worker tag db writing test.

* Move the server table back to the top.

* Update comment for the worker object.

* Update comment for the worker table.

* Update the newWorkerId call to take a context and fix its error.

* Correct comment for the wt_network_address domain.
2022-05-18 17:03:24 -07:00

271 lines
7.5 KiB
Go

package servers_test
import (
"context"
"testing"
"time"
"github.com/hashicorp/boundary/api/recovery"
"github.com/hashicorp/boundary/api/roles"
"github.com/hashicorp/boundary/globals"
"github.com/hashicorp/boundary/internal/daemon/controller"
"github.com/hashicorp/boundary/internal/db"
"github.com/hashicorp/boundary/internal/kms"
"github.com/hashicorp/boundary/internal/servers"
"github.com/hashicorp/boundary/internal/types/scope"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRecoveryNonces(t *testing.T) {
assert, require := assert.New(t), require.New(t)
// Set these low so that we can not have the test run forever
globals.RecoveryTokenValidityPeriod = 10 * time.Second
globals.WorkerAuthNonceValidityPeriod = 10 * time.Second
controller.NonceCleanupInterval = 20 * time.Second
wrapper := db.TestWrapper(t)
tc := controller.NewTestController(t, &controller.TestControllerOpts{
RecoveryKms: wrapper,
})
defer tc.Shutdown()
externalWrappers := tc.Kms().GetExternalWrappers(context.Background())
externalRecovery := externalWrappers.Recovery()
require.Equal(externalRecovery, wrapper)
client := tc.Client()
repo := tc.ServersRepo()
// First, validate that we can't use the same token twice. Get two tokens,
// try to use the first twice (should succeed first time, fail second), then
// ensure second token works
token1, err := recovery.GenerateRecoveryToken(tc.Context(), wrapper)
require.NoError(err)
token2, err := recovery.GenerateRecoveryToken(tc.Context(), wrapper)
require.NoError(err)
// Token 1, try 1
client.SetToken(token1)
roleClient := roles.NewClient(client)
_, err = roleClient.Create(tc.Context(), scope.Global.String())
require.NoError(err)
nonces, err := repo.ListNonces(tc.Context(), servers.NoncePurposeRecovery)
require.NoError(err)
assert.Len(nonces, 1)
// Token 1, try 2
_, err = roleClient.Create(tc.Context(), scope.Global.String())
require.Error(err)
nonces, err = repo.ListNonces(tc.Context(), servers.NoncePurposeRecovery)
require.NoError(err)
assert.Len(nonces, 1)
// Token 2
roleClient.ApiClient().SetToken(token2)
_, err = roleClient.Create(tc.Context(), scope.Global.String())
require.NoError(err)
nonces, err = repo.ListNonces(tc.Context(), servers.NoncePurposeRecovery)
require.NoError(err)
assert.Len(nonces, 2)
// Make sure they get cleaned up
time.Sleep(2 * controller.NonceCleanupInterval)
nonces, err = repo.ListNonces(tc.Context(), servers.NoncePurposeRecovery)
require.NoError(err)
assert.Len(nonces, 0)
// And finally, make sure they still can't be used
for _, token := range []string{token1, token2} {
roleClient.ApiClient().SetToken(token)
_, err = roleClient.Create(tc.Context(), scope.Global.String())
require.Error(err)
nonces, err = repo.ListNonces(tc.Context(), servers.NoncePurposeRecovery)
require.NoError(err)
assert.Len(nonces, 0)
}
}
func TestTagUpdatingListing(t *testing.T) {
require := require.New(t)
wrapper := db.TestWrapper(t)
tc := controller.NewTestController(t, &controller.TestControllerOpts{
RecoveryKms: wrapper,
})
defer tc.Shutdown()
repo := tc.ServersRepo()
srv := servers.NewWorker(scope.Global.String(),
servers.WithPublicId("test_worker_1"),
servers.WithAddress("127.0.0.1"),
servers.WithWorkerTags(
&servers.Tag{
Key: "tag1",
Value: "value1",
},
&servers.Tag{
Key: "tag1",
Value: "value2",
}))
_, _, err := repo.UpsertWorker(tc.Context(), srv, servers.WithUpdateTags(true))
require.NoError(err)
srv = servers.NewWorker(scope.Global.String(),
servers.WithPublicId("test_worker_2"),
servers.WithAddress("127.0.0.1"),
servers.WithWorkerTags(
&servers.Tag{
Key: "tag2",
Value: "value1",
},
&servers.Tag{
Key: "tag2",
Value: "value2",
}))
_, _, err = repo.UpsertWorker(tc.Context(), srv, servers.WithUpdateTags(true))
require.NoError(err)
tags, err := repo.ListTagsForWorkers(tc.Context(), []string{"test_worker_1", "test_worker_2"})
require.NoError(err)
// Base case
exp := map[string][]*servers.Tag{
"test_worker_1": {
{
Key: "tag1",
Value: "value1",
}, {
Key: "tag1",
Value: "value2",
},
},
"test_worker_2": {
{
Key: "tag2",
Value: "value1",
},
{
Key: "tag2",
Value: "value2",
},
},
}
require.Equal(exp, tags)
// Update without saying to update tags
srv = servers.NewWorker(scope.Global.String(),
servers.WithPublicId("test_worker_2"),
servers.WithAddress("192.168.1.1"),
servers.WithWorkerTags(
&servers.Tag{
Key: "tag22",
Value: "value21",
},
&servers.Tag{
Key: "tag22",
Value: "value22",
}))
_, _, err = repo.UpsertWorker(tc.Context(), srv)
require.NoError(err)
tags, err = repo.ListTagsForWorkers(tc.Context(), []string{"test_worker_1", "test_worker_2"})
require.NoError(err)
require.Equal(exp, tags)
// Update tags and test again
_, _, err = repo.UpsertWorker(tc.Context(), srv, servers.WithUpdateTags(true))
require.NoError(err)
tags, err = repo.ListTagsForWorkers(tc.Context(), []string{"test_worker_1", "test_worker_2"})
require.NoError(err)
require.NotEqual(exp, tags)
// Update and try again
exp["test_worker_2"] = []*servers.Tag{
{
Key: "tag22",
Value: "value21",
},
{
Key: "tag22",
Value: "value22",
},
}
require.Equal(exp, tags)
}
func TestListServersWithLiveness(t *testing.T) {
t.Parallel()
require := require.New(t)
conn, _ := db.TestSetup(t, "postgres")
rw := db.New(conn)
wrapper := db.TestWrapper(t)
kms := kms.TestKms(t, conn, wrapper)
serversRepo, err := servers.NewRepository(rw, rw, kms)
require.NoError(err)
ctx := context.Background()
newWorker := func(publicId string) *servers.Worker {
result := servers.NewWorker(scope.Global.String(),
servers.WithPublicId(publicId),
servers.WithAddress("127.0.0.1"))
_, rowsUpdated, err := serversRepo.UpsertWorker(ctx, result)
require.NoError(err)
require.Equal(1, rowsUpdated)
return result
}
server1 := newWorker("test_worker_1")
server2 := newWorker("test_worker_2")
server3 := newWorker("test_worker_3")
// Sleep the default liveness time (15sec currently) +1s
time.Sleep(time.Second * 16)
// Push an upsert to the first worker so that its status has been
// updated.
_, rowsUpdated, err := serversRepo.UpsertWorker(ctx, server1)
require.NoError(err)
require.Equal(1, rowsUpdated)
requireIds := func(expected []string, actual []*servers.Worker) {
require.Len(expected, len(actual))
want := make(map[string]struct{})
for _, v := range expected {
want[v] = struct{}{}
}
got := make(map[string]struct{})
for _, v := range actual {
got[v.PublicId] = struct{}{}
}
require.Equal(want, got)
}
// Default liveness, should only list 1
result, err := serversRepo.ListWorkers(ctx)
require.NoError(err)
require.Len(result, 1)
requireIds([]string{server1.PublicId}, result)
// Upsert second server.
_, rowsUpdated, err = serversRepo.UpsertWorker(ctx, server2)
require.NoError(err)
require.Equal(1, rowsUpdated)
// Static liveness. Should get two, so long as this did not take
// more than 5s to execute.
result, err = serversRepo.ListWorkers(ctx, servers.WithLiveness(time.Second*5))
require.NoError(err)
require.Len(result, 2)
requireIds([]string{server1.PublicId, server2.PublicId}, result)
// Liveness disabled, should get all three workers.
result, err = serversRepo.ListWorkers(ctx, servers.WithLiveness(-1))
require.NoError(err)
require.Len(result, 3)
requireIds([]string{server1.PublicId, server2.PublicId, server3.PublicId}, result)
}