mirror of https://github.com/status-im/consul.git
794 lines
25 KiB
Go
794 lines
25 KiB
Go
package xds
|
|
|
|
import (
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
envoy_api_v2 "github.com/envoyproxy/go-control-plane/envoy/api/v2"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
"github.com/golang/protobuf/ptypes"
|
|
"github.com/golang/protobuf/ptypes/any"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"github.com/hashicorp/consul/acl"
|
|
"github.com/hashicorp/consul/agent/proxycfg"
|
|
"github.com/hashicorp/consul/agent/structs"
|
|
)
|
|
|
|
// NOTE: For these tests, prefer not using xDS protobuf "factory" methods if
|
|
// possible to avoid using them to test themselves.
|
|
//
|
|
// Stick to very straightforward stuff in xds_protocol_helpers_test.go.
|
|
|
|
func TestServer_StreamAggregatedResources_v2_BasicProtocol_TCP(t *testing.T) {
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
// Allow all
|
|
return acl.RootAuthorizer("manage"), nil
|
|
}
|
|
scenario := newTestServerScenario(t, aclResolve, "web-sidecar-proxy", "", 0)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
sid := structs.NewServiceID("web-sidecar-proxy", nil)
|
|
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Send initial cluster discover (empty payload)
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
requireProtocolVersionGauge(t, scenario, "v2", 1)
|
|
|
|
// Deliver a new snapshot
|
|
snap := newTestSnapshot(t, nil, "")
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
expectClusterResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: ClusterType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestCluster_v2(t, snap, "tcp:local_app"),
|
|
makeTestCluster_v2(t, snap, "tcp:db"),
|
|
makeTestCluster_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
expectEndpointResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: EndpointType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestEndpoints_v2(t, snap, "tcp:db"),
|
|
makeTestEndpoints_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
expectListenerResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: ListenerType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestListener_v2(t, snap, "tcp:public_listener"),
|
|
makeTestListener_v2(t, snap, "tcp:db"),
|
|
makeTestListener_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
|
|
assertResponseSent(t, envoy.stream.sendCh, expectClusterResponse(1, 1))
|
|
|
|
// Envoy then tries to discover endpoints for those clusters. Technically it
|
|
// includes the cluster names in the ResourceNames field but we ignore that
|
|
// completely for now so not bothering to simulate that.
|
|
envoy.SendReq(t, EndpointType_v2, 0, 0)
|
|
|
|
// It also (in parallel) issues the next cluster request (which acts as an ACK
|
|
// of the version we sent)
|
|
envoy.SendReq(t, ClusterType_v2, 1, 1)
|
|
|
|
// We should get a response immediately since the config is already present in
|
|
// the server for endpoints. Note that this should not be racy if the server
|
|
// is behaving well since the Cluster send above should be blocked until we
|
|
// deliver a new config version.
|
|
assertResponseSent(t, envoy.stream.sendCh, expectEndpointResponse(1, 2))
|
|
|
|
// And no other response yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// Envoy now sends listener request along with next endpoint one
|
|
envoy.SendReq(t, ListenerType_v2, 0, 0)
|
|
envoy.SendReq(t, EndpointType_v2, 1, 2)
|
|
|
|
// And should get a response immediately.
|
|
assertResponseSent(t, envoy.stream.sendCh, expectListenerResponse(1, 3))
|
|
|
|
// Now send Route request along with next listener one
|
|
envoy.SendReq(t, RouteType_v2, 0, 0)
|
|
envoy.SendReq(t, ListenerType_v2, 1, 3)
|
|
|
|
// We don't serve routes yet so this should block with no response
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// WOOP! Envoy now has full connect config. Lets verify that if we update it,
|
|
// all the responses get resent with the new version. We don't actually want
|
|
// to change everything because that's tedious - our implementation will
|
|
// actually resend all blocked types on the new "version" anyway since it
|
|
// doesn't know _what_ changed. We could do something trivial but let's
|
|
// simulate a leaf cert expiring and being rotated.
|
|
snap.ConnectProxy.Leaf = proxycfg.TestLeafForCA(t, snap.Roots.Roots[0])
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
// All 3 response that have something to return should return with new version
|
|
// note that the ordering is not deterministic in general. Trying to make this
|
|
// test order-agnostic though is a massive pain because we
|
|
// don't know the order the nonces will be assigned. For now we rely and
|
|
// require our implementation to always deliver updates in a specific order
|
|
// which is reasonable anyway to ensure consistency of the config Envoy sees.
|
|
assertResponseSent(t, envoy.stream.sendCh, expectClusterResponse(2, 4))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectEndpointResponse(2, 5))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectListenerResponse(2, 6))
|
|
|
|
// Let's pretend that Envoy doesn't like that new listener config. It will ACK
|
|
// all the others (same version) but NACK the listener. This is the most
|
|
// subtle part of xDS and the server implementation so I'll elaborate. A full
|
|
// description of the protocol can be found at
|
|
// https://www.envoyproxy.io/docs/envoy/latest/api-docs/xds_protocol
|
|
// Envoy delays making a followup request for a type until after it has
|
|
// processed and applied the last response. The next request then will include
|
|
// the nonce in the last response which acknowledges _receiving_ and handling
|
|
// that response. It also includes the currently applied version. If all is
|
|
// good and it successfully applies the config, then the version in the next
|
|
// response will be the same version just sent. This is considered to be an
|
|
// ACK of that version for that type. If envoy fails to apply the config for
|
|
// some reason, it will still acknowledge that it received it (still return
|
|
// the responses nonce), but will show the previous version it's still using.
|
|
// This is considered a NACK. It's important that the server pay attention to
|
|
// the _nonce_ and not the version when deciding what to send otherwise a bad
|
|
// version that can't be applied in Envoy will cause a busy loop.
|
|
//
|
|
// In this case we are simulating that Envoy failed to apply the Listener
|
|
// response but did apply the other types so all get the new nonces, but
|
|
// listener stays on v1.
|
|
envoy.SendReq(t, ClusterType_v2, 2, 4)
|
|
envoy.SendReq(t, EndpointType_v2, 2, 5)
|
|
envoy.SendReq(t, ListenerType_v2, 1, 6)
|
|
|
|
// Even though we nacked, we should still NOT get then v2 listeners
|
|
// redelivered since nothing has changed.
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// Change config again and make sure it's delivered to everyone!
|
|
snap.ConnectProxy.Leaf = proxycfg.TestLeafForCA(t, snap.Roots.Roots[0])
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
assertResponseSent(t, envoy.stream.sendCh, expectClusterResponse(3, 7))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectEndpointResponse(3, 8))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectListenerResponse(3, 9))
|
|
|
|
envoy.Close()
|
|
select {
|
|
case err := <-errCh:
|
|
require.NoError(t, err)
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
}
|
|
|
|
func TestServer_StreamAggregatedResources_v2_BasicProtocol_HTTP(t *testing.T) {
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
// Allow all
|
|
return acl.RootAuthorizer("manage"), nil
|
|
}
|
|
scenario := newTestServerScenario(t, aclResolve, "web-sidecar-proxy", "", 0)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
sid := structs.NewServiceID("web-sidecar-proxy", nil)
|
|
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Send initial cluster discover (empty payload)
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// Deliver a new snapshot
|
|
// Deliver a new snapshot (tcp with one http upstream)
|
|
snap := newTestSnapshot(t, nil, "http2", &structs.ServiceConfigEntry{
|
|
Kind: structs.ServiceDefaults,
|
|
Name: "db",
|
|
Protocol: "http2",
|
|
})
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
expectClusterResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: ClusterType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestCluster_v2(t, snap, "tcp:local_app"),
|
|
makeTestCluster_v2(t, snap, "http2:db"),
|
|
makeTestCluster_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
expectEndpointResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: EndpointType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestEndpoints_v2(t, snap, "http2:db"),
|
|
makeTestEndpoints_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
expectListenerResponse := func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: ListenerType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestListener_v2(t, snap, "tcp:public_listener"),
|
|
makeTestListener_v2(t, snap, "http2:db"),
|
|
makeTestListener_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
|
|
runStep(t, "no-rds", func(t *testing.T) {
|
|
|
|
// REQ: clusters
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
|
|
// RESP: clusters
|
|
assertResponseSent(t, envoy.stream.sendCh, expectClusterResponse(1, 1))
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// REQ: endpoints
|
|
envoy.SendReq(t, EndpointType_v2, 0, 0)
|
|
|
|
// ACK: clusters
|
|
envoy.SendReq(t, ClusterType_v2, 1, 1)
|
|
|
|
// RESP: endpoints
|
|
assertResponseSent(t, envoy.stream.sendCh, expectEndpointResponse(1, 2))
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// REQ: listeners
|
|
envoy.SendReq(t, ListenerType_v2, 0, 0)
|
|
|
|
// ACK: endpoints
|
|
envoy.SendReq(t, EndpointType_v2, 1, 2)
|
|
|
|
// RESP: listeners
|
|
assertResponseSent(t, envoy.stream.sendCh, expectListenerResponse(1, 3))
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// ACK: listeners
|
|
envoy.SendReq(t, ListenerType_v2, 1, 3)
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
})
|
|
|
|
// -- reconfigure with a no-op discovery chain
|
|
|
|
snap = newTestSnapshot(t, snap, "http2", &structs.ServiceConfigEntry{
|
|
Kind: structs.ServiceDefaults,
|
|
Name: "db",
|
|
Protocol: "http2",
|
|
}, &structs.ServiceRouterConfigEntry{
|
|
Kind: structs.ServiceRouter,
|
|
Name: "db",
|
|
Routes: nil,
|
|
})
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
// update this test helper to reflect the RDS-linked listener
|
|
expectListenerResponse = func(v, n uint64) *envoy_api_v2.DiscoveryResponse {
|
|
return &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(v),
|
|
TypeUrl: ListenerType_v2,
|
|
Nonce: hexString(n),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestListener_v2(t, snap, "tcp:public_listener"),
|
|
makeTestListener_v2(t, snap, "http2:db:rds"),
|
|
makeTestListener_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
}
|
|
}
|
|
|
|
runStep(t, "with-rds", func(t *testing.T) {
|
|
// RESP: listeners (but also a stray update of the other registered types)
|
|
assertResponseSent(t, envoy.stream.sendCh, expectClusterResponse(2, 4))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectEndpointResponse(2, 5))
|
|
assertResponseSent(t, envoy.stream.sendCh, expectListenerResponse(2, 6))
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// ACK: listeners (but also stray ACKs of the other registered types)
|
|
envoy.SendReq(t, ClusterType_v2, 2, 4)
|
|
envoy.SendReq(t, EndpointType_v2, 2, 5)
|
|
envoy.SendReq(t, ListenerType_v2, 2, 6)
|
|
|
|
// REQ: routes
|
|
envoy.SendReq(t, RouteType_v2, 0, 0)
|
|
|
|
// RESP: routes
|
|
assertResponseSent(t, envoy.stream.sendCh, &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(2),
|
|
TypeUrl: RouteType_v2,
|
|
Nonce: hexString(7),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestRoute_v2(t, "http2:db"),
|
|
),
|
|
})
|
|
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// ACK: routes
|
|
envoy.SendReq(t, RouteType_v2, 2, 7)
|
|
})
|
|
|
|
envoy.Close()
|
|
select {
|
|
case err := <-errCh:
|
|
require.NoError(t, err)
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
}
|
|
|
|
func TestServer_StreamAggregatedResources_v2_ACLEnforcement(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
defaultDeny bool
|
|
acl string
|
|
token string
|
|
wantDenied bool
|
|
cfgSnap *proxycfg.ConfigSnapshot
|
|
}{
|
|
// Note that although we've stubbed actual ACL checks in the testManager
|
|
// ConnectAuthorize mock, by asserting against specific reason strings here
|
|
// even in the happy case which can't match the default one returned by the
|
|
// mock we are implicitly validating that the implementation used the
|
|
// correct token from the context.
|
|
{
|
|
name: "no ACLs configured",
|
|
defaultDeny: false,
|
|
wantDenied: false,
|
|
},
|
|
{
|
|
name: "default deny, no token",
|
|
defaultDeny: true,
|
|
wantDenied: true,
|
|
},
|
|
{
|
|
name: "default deny, write token",
|
|
defaultDeny: true,
|
|
acl: `service "web" { policy = "write" }`,
|
|
token: "service-write-on-web",
|
|
wantDenied: false,
|
|
},
|
|
{
|
|
name: "default deny, read token",
|
|
defaultDeny: true,
|
|
acl: `service "web" { policy = "read" }`,
|
|
token: "service-write-on-web",
|
|
wantDenied: true,
|
|
},
|
|
{
|
|
name: "default deny, write token on different service",
|
|
defaultDeny: true,
|
|
acl: `service "not-web" { policy = "write" }`,
|
|
token: "service-write-on-not-web",
|
|
wantDenied: true,
|
|
},
|
|
{
|
|
name: "ingress default deny, write token on different service",
|
|
defaultDeny: true,
|
|
acl: `service "not-ingress" { policy = "write" }`,
|
|
token: "service-write-on-not-ingress",
|
|
wantDenied: true,
|
|
cfgSnap: proxycfg.TestConfigSnapshotIngressGateway(t),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
if !tt.defaultDeny {
|
|
// Allow all
|
|
return acl.RootAuthorizer("allow"), nil
|
|
}
|
|
if tt.acl == "" {
|
|
// No token and defaultDeny is denied
|
|
return acl.RootAuthorizer("deny"), nil
|
|
}
|
|
// Ensure the correct token was passed
|
|
require.Equal(t, tt.token, id)
|
|
// Parse the ACL and enforce it
|
|
policy, err := acl.NewPolicyFromSource("", 0, tt.acl, acl.SyntaxLegacy, nil, nil)
|
|
require.NoError(t, err)
|
|
return acl.NewPolicyAuthorizerWithDefaults(acl.RootAuthorizer("deny"), []*acl.Policy{policy}, nil)
|
|
}
|
|
|
|
scenario := newTestServerScenario(t, aclResolve, "web-sidecar-proxy", tt.token, 0)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
sid := structs.NewServiceID("web-sidecar-proxy", nil)
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Deliver a new snapshot
|
|
snap := tt.cfgSnap
|
|
if snap == nil {
|
|
snap = newTestSnapshot(t, nil, "")
|
|
}
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
// Send initial listener discover, in real life Envoy always sends cluster
|
|
// first but it doesn't really matter and listener has a response that
|
|
// includes the token in the ext rbac filter so lets us test more stuff.
|
|
envoy.SendReq(t, ListenerType_v2, 0, 0)
|
|
|
|
if !tt.wantDenied {
|
|
assertResponseSent(t, envoy.stream.sendCh, &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: ListenerType_v2,
|
|
Nonce: hexString(1),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestListener_v2(t, snap, "tcp:public_listener"),
|
|
makeTestListener_v2(t, snap, "tcp:db"),
|
|
makeTestListener_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
})
|
|
// Close the client stream since all is well. We _don't_ do this in the
|
|
// expected error case because we want to verify the error closes the
|
|
// stream from server side.
|
|
envoy.Close()
|
|
}
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
if tt.wantDenied {
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
mgr.AssertWatchCancelled(t, sid)
|
|
} else {
|
|
require.NoError(t, err)
|
|
}
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestServer_StreamAggregatedResources_v2_ACLTokenDeleted_StreamTerminatedDuringDiscoveryRequest(t *testing.T) {
|
|
aclRules := `service "web" { policy = "write" }`
|
|
token := "service-write-on-web"
|
|
|
|
policy, err := acl.NewPolicyFromSource("", 0, aclRules, acl.SyntaxLegacy, nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
var validToken atomic.Value
|
|
validToken.Store(token)
|
|
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
if token := validToken.Load(); token == nil || id != token.(string) {
|
|
return nil, acl.ErrNotFound
|
|
}
|
|
|
|
return acl.NewPolicyAuthorizerWithDefaults(acl.RootAuthorizer("deny"), []*acl.Policy{policy}, nil)
|
|
}
|
|
scenario := newTestServerScenario(t, aclResolve, "web-sidecar-proxy", token,
|
|
1*time.Hour, // make sure this doesn't kick in
|
|
)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
getError := func() (gotErr error, ok bool) {
|
|
select {
|
|
case err := <-errCh:
|
|
return err, true
|
|
default:
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
sid := structs.NewServiceID("web-sidecar-proxy", nil)
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Send initial cluster discover (OK)
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
{
|
|
err, ok := getError()
|
|
require.NoError(t, err)
|
|
require.False(t, ok)
|
|
}
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
{
|
|
err, ok := getError()
|
|
require.NoError(t, err)
|
|
require.False(t, ok)
|
|
}
|
|
|
|
// Deliver a new snapshot
|
|
snap := newTestSnapshot(t, nil, "")
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
assertResponseSent(t, envoy.stream.sendCh, &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: ClusterType_v2,
|
|
Nonce: hexString(1),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestCluster_v2(t, snap, "tcp:local_app"),
|
|
makeTestCluster_v2(t, snap, "tcp:db"),
|
|
makeTestCluster_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
})
|
|
|
|
// Now nuke the ACL token.
|
|
validToken.Store("")
|
|
|
|
// It also (in parallel) issues the next cluster request (which acts as an ACK
|
|
// of the version we sent)
|
|
envoy.SendReq(t, ClusterType_v2, 1, 1)
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
require.Error(t, err)
|
|
gerr, ok := status.FromError(err)
|
|
require.Truef(t, ok, "not a grpc status error: type='%T' value=%v", err, err)
|
|
require.Equal(t, codes.Unauthenticated, gerr.Code())
|
|
require.Equal(t, "unauthenticated: ACL not found", gerr.Message())
|
|
|
|
mgr.AssertWatchCancelled(t, sid)
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
}
|
|
|
|
func TestServer_StreamAggregatedResources_v2_ACLTokenDeleted_StreamTerminatedInBackground(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("too slow for testing.Short")
|
|
}
|
|
|
|
aclRules := `service "web" { policy = "write" }`
|
|
token := "service-write-on-web"
|
|
|
|
policy, err := acl.NewPolicyFromSource("", 0, aclRules, acl.SyntaxLegacy, nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
var validToken atomic.Value
|
|
validToken.Store(token)
|
|
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
if token := validToken.Load(); token == nil || id != token.(string) {
|
|
return nil, acl.ErrNotFound
|
|
}
|
|
|
|
return acl.NewPolicyAuthorizerWithDefaults(acl.RootAuthorizer("deny"), []*acl.Policy{policy}, nil)
|
|
}
|
|
scenario := newTestServerScenario(t, aclResolve, "web-sidecar-proxy", token,
|
|
100*time.Millisecond, // Make this short.
|
|
)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
getError := func() (gotErr error, ok bool) {
|
|
select {
|
|
case err := <-errCh:
|
|
return err, true
|
|
default:
|
|
return nil, false
|
|
}
|
|
}
|
|
|
|
sid := structs.NewServiceID("web-sidecar-proxy", nil)
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Send initial cluster discover (OK)
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
{
|
|
err, ok := getError()
|
|
require.NoError(t, err)
|
|
require.False(t, ok)
|
|
}
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
{
|
|
err, ok := getError()
|
|
require.NoError(t, err)
|
|
require.False(t, ok)
|
|
}
|
|
|
|
// Deliver a new snapshot
|
|
snap := newTestSnapshot(t, nil, "")
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
assertResponseSent(t, envoy.stream.sendCh, &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: ClusterType_v2,
|
|
Nonce: hexString(1),
|
|
Resources: makeTestResources_v2(t,
|
|
makeTestCluster_v2(t, snap, "tcp:local_app"),
|
|
makeTestCluster_v2(t, snap, "tcp:db"),
|
|
makeTestCluster_v2(t, snap, "tcp:geo-cache"),
|
|
),
|
|
})
|
|
|
|
// It also (in parallel) issues the next cluster request (which acts as an ACK
|
|
// of the version we sent)
|
|
envoy.SendReq(t, ClusterType_v2, 1, 1)
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
{
|
|
err, ok := getError()
|
|
require.NoError(t, err)
|
|
require.False(t, ok)
|
|
}
|
|
|
|
// Now nuke the ACL token while there's no activity.
|
|
validToken.Store("")
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
require.Error(t, err)
|
|
gerr, ok := status.FromError(err)
|
|
require.Truef(t, ok, "not a grpc status error: type='%T' value=%v", err, err)
|
|
require.Equal(t, codes.Unauthenticated, gerr.Code())
|
|
require.Equal(t, "unauthenticated: ACL not found", gerr.Message())
|
|
|
|
mgr.AssertWatchCancelled(t, sid)
|
|
case <-time.After(200 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
}
|
|
|
|
func TestServer_StreamAggregatedResources_v2_IngressEmptyResponse(t *testing.T) {
|
|
aclResolve := func(id string) (acl.Authorizer, error) {
|
|
// Allow all
|
|
return acl.RootAuthorizer("manage"), nil
|
|
}
|
|
scenario := newTestServerScenario(t, aclResolve, "ingress-gateway", "", 0)
|
|
mgr, errCh, envoy := scenario.mgr, scenario.errCh, scenario.envoy
|
|
|
|
sid := structs.NewServiceID("ingress-gateway", nil)
|
|
|
|
// Register the proxy to create state needed to Watch() on
|
|
mgr.RegisterProxy(t, sid)
|
|
|
|
// Send initial cluster discover
|
|
envoy.SendReq(t, ClusterType_v2, 0, 0)
|
|
|
|
// Check no response sent yet
|
|
assertChanBlocked(t, envoy.stream.sendCh)
|
|
|
|
// Deliver a new snapshot with no services
|
|
snap := proxycfg.TestConfigSnapshotIngressGatewayNoServices(t)
|
|
mgr.DeliverConfig(t, sid, snap)
|
|
|
|
emptyClusterResp := &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: ClusterType_v2,
|
|
Nonce: hexString(1),
|
|
}
|
|
emptyListenerResp := &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: ListenerType_v2,
|
|
Nonce: hexString(2),
|
|
}
|
|
emptyRouteResp := &envoy_api_v2.DiscoveryResponse{
|
|
VersionInfo: hexString(1),
|
|
TypeUrl: RouteType_v2,
|
|
Nonce: hexString(3),
|
|
}
|
|
|
|
assertResponseSent(t, envoy.stream.sendCh, emptyClusterResp)
|
|
|
|
// Send initial listener discover
|
|
envoy.SendReq(t, ListenerType_v2, 0, 0)
|
|
assertResponseSent(t, envoy.stream.sendCh, emptyListenerResp)
|
|
|
|
envoy.SendReq(t, RouteType_v2, 0, 0)
|
|
assertResponseSent(t, envoy.stream.sendCh, emptyRouteResp)
|
|
|
|
envoy.Close()
|
|
select {
|
|
case err := <-errCh:
|
|
require.NoError(t, err)
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("timed out waiting for handler to finish")
|
|
}
|
|
}
|
|
|
|
func assertChanBlocked(t *testing.T, ch chan *envoy_api_v2.DiscoveryResponse) {
|
|
t.Helper()
|
|
select {
|
|
case r := <-ch:
|
|
t.Fatalf("chan should block but received: %v", r)
|
|
case <-time.After(10 * time.Millisecond):
|
|
return
|
|
}
|
|
}
|
|
|
|
func assertResponseSent(t *testing.T, ch chan *envoy_api_v2.DiscoveryResponse, want *envoy_api_v2.DiscoveryResponse) {
|
|
t.Helper()
|
|
select {
|
|
case got := <-ch:
|
|
assertResponse(t, got, want)
|
|
case <-time.After(50 * time.Millisecond):
|
|
t.Fatalf("no response received after 50ms")
|
|
}
|
|
}
|
|
|
|
// assertResponse is a helper to test a envoy.DiscoveryResponse matches the
|
|
// expected value. We use JSON during comparison here because the responses use protobuf
|
|
// Any type which includes binary protobuf encoding.
|
|
func assertResponse(t *testing.T, got, want *envoy_api_v2.DiscoveryResponse) {
|
|
t.Helper()
|
|
|
|
gotJSON := protoToJSON(t, got)
|
|
wantJSON := protoToJSON(t, want)
|
|
require.JSONEqf(t, wantJSON, gotJSON, "got:\n%s", gotJSON)
|
|
}
|
|
|
|
func makeTestResources_v2(t *testing.T, resources ...proto.Message) []*any.Any {
|
|
var ret []*any.Any
|
|
for _, res := range resources {
|
|
any, err := ptypes.MarshalAny(res)
|
|
require.NoError(t, err)
|
|
ret = append(ret, any)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func makeTestListener_v2(t *testing.T, snap *proxycfg.ConfigSnapshot, fixtureName string) *envoy_api_v2.Listener {
|
|
v3 := makeTestListener(t, snap, fixtureName)
|
|
v2, err := convertListenerToV2(v3)
|
|
require.NoError(t, err)
|
|
return v2
|
|
}
|
|
|
|
func makeTestCluster_v2(t *testing.T, snap *proxycfg.ConfigSnapshot, fixtureName string) *envoy_api_v2.Cluster {
|
|
v3 := makeTestCluster(t, snap, fixtureName)
|
|
v2, err := convertClusterToV2(v3)
|
|
require.NoError(t, err)
|
|
return v2
|
|
}
|
|
|
|
func makeTestEndpoints_v2(t *testing.T, snap *proxycfg.ConfigSnapshot, fixtureName string) *envoy_api_v2.ClusterLoadAssignment {
|
|
v3 := makeTestEndpoints(t, snap, fixtureName)
|
|
v2, err := convertClusterLoadAssignmentToV2(v3)
|
|
require.NoError(t, err)
|
|
return v2
|
|
}
|
|
|
|
func makeTestRoute_v2(t *testing.T, fixtureName string) *envoy_api_v2.RouteConfiguration {
|
|
v3 := makeTestRoute(t, fixtureName)
|
|
v2, err := convertRouteConfigurationToV2(v3)
|
|
require.NoError(t, err)
|
|
return v2
|
|
}
|