490 lines
14 KiB
Go
490 lines
14 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
package fingerprint
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/nomad/ci"
|
|
"github.com/hashicorp/nomad/client/config"
|
|
"github.com/hashicorp/nomad/helper/testlog"
|
|
"github.com/hashicorp/nomad/nomad/structs"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestEnvAWSFingerprint_nonAws(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = "http://127.0.0.1/latest"
|
|
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
require.Empty(t, response.Attributes)
|
|
}
|
|
|
|
func TestEnvAWSFingerprint_aws(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, awsStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
keys := []string{
|
|
"platform.aws.ami-id",
|
|
"unique.platform.aws.hostname",
|
|
"unique.platform.aws.instance-id",
|
|
"platform.aws.instance-life-cycle",
|
|
"platform.aws.instance-type",
|
|
"unique.platform.aws.local-hostname",
|
|
"unique.platform.aws.local-ipv4",
|
|
"unique.platform.aws.public-hostname",
|
|
"unique.platform.aws.public-ipv4",
|
|
"platform.aws.placement.availability-zone",
|
|
"unique.network.ip-address",
|
|
}
|
|
|
|
for _, k := range keys {
|
|
assertNodeAttributeContains(t, response.Attributes, k)
|
|
}
|
|
|
|
require.NotEmpty(t, response.Links)
|
|
|
|
// confirm we have at least instance-id and ami-id
|
|
for _, k := range []string{"aws.ec2"} {
|
|
assertNodeLinksContains(t, response.Links, k)
|
|
}
|
|
}
|
|
|
|
func TestNetworkFingerprint_AWS(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, awsStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
assertNodeAttributeContains(t, response.Attributes, "unique.network.ip-address")
|
|
|
|
require.NotNil(t, response.NodeResources)
|
|
require.Len(t, response.NodeResources.Networks, 1)
|
|
|
|
// Test at least the first Network Resource
|
|
net := response.NodeResources.Networks[0]
|
|
require.NotEmpty(t, net.IP, "Expected Network Resource to have an IP")
|
|
require.NotEmpty(t, net.CIDR, "Expected Network Resource to have a CIDR")
|
|
require.NotEmpty(t, net.Device, "Expected Network Resource to have a Device Name")
|
|
}
|
|
|
|
func TestNetworkFingerprint_AWS_network(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, awsStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
{
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
require.True(t, response.Detected, "expected response to be applicable")
|
|
|
|
assertNodeAttributeContains(t, response.Attributes, "unique.network.ip-address")
|
|
|
|
require.NotNil(t, response.NodeResources)
|
|
require.Len(t, response.NodeResources.Networks, 1)
|
|
|
|
// Test at least the first Network Resource
|
|
net := response.NodeResources.Networks[0]
|
|
require.NotEmpty(t, net.IP, "Expected Network Resource to have an IP")
|
|
require.NotEmpty(t, net.CIDR, "Expected Network Resource to have a CIDR")
|
|
require.NotEmpty(t, net.Device, "Expected Network Resource to have a Device Name")
|
|
require.Equal(t, 1000, net.MBits)
|
|
}
|
|
|
|
// Try again this time setting a network speed in the config
|
|
{
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
cfg := &config.Config{
|
|
NetworkSpeed: 10,
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: cfg, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
assertNodeAttributeContains(t, response.Attributes, "unique.network.ip-address")
|
|
|
|
require.NotNil(t, response.NodeResources)
|
|
require.Len(t, response.NodeResources.Networks, 1)
|
|
|
|
// Test at least the first Network Resource
|
|
net := response.NodeResources.Networks[0]
|
|
require.NotEmpty(t, net.IP, "Expected Network Resource to have an IP")
|
|
require.NotEmpty(t, net.CIDR, "Expected Network Resource to have a CIDR")
|
|
require.NotEmpty(t, net.Device, "Expected Network Resource to have a Device Name")
|
|
require.Equal(t, 10, net.MBits)
|
|
}
|
|
}
|
|
|
|
func TestNetworkFingerprint_AWS_NoNetwork(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, noNetworkAWSStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
require.True(t, response.Detected, "expected response to be applicable")
|
|
|
|
require.Equal(t, "ami-1234", response.Attributes["platform.aws.ami-id"])
|
|
|
|
require.Nil(t, response.NodeResources.Networks)
|
|
}
|
|
|
|
func TestNetworkFingerprint_AWS_IncompleteImitation(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, incompleteAWSImitationStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{
|
|
Attributes: make(map[string]string),
|
|
}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
|
|
require.False(t, response.Detected, "expected response not to be applicable")
|
|
|
|
require.NotContains(t, response.Attributes, "platform.aws.ami-id")
|
|
require.Nil(t, response.NodeResources)
|
|
}
|
|
|
|
func TestCPUFingerprint_AWS_InstanceFound(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, awsStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{Attributes: make(map[string]string)}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
require.True(t, response.Detected)
|
|
require.Equal(t, "2200", response.Attributes["cpu.frequency"])
|
|
require.Equal(t, "8", response.Attributes["cpu.numcores"])
|
|
require.Equal(t, "17600", response.Attributes["cpu.totalcompute"])
|
|
require.Equal(t, 17600, response.Resources.CPU)
|
|
require.Equal(t, int64(17600), response.NodeResources.Cpu.CpuShares)
|
|
}
|
|
|
|
func TestCPUFingerprint_AWS_OverrideCompute(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, awsStubs)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{Attributes: make(map[string]string)}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{
|
|
CpuCompute: 99999,
|
|
}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
require.True(t, response.Detected)
|
|
require.Equal(t, "2200", response.Attributes["cpu.frequency"])
|
|
require.Equal(t, "8", response.Attributes["cpu.numcores"])
|
|
require.Equal(t, "99999", response.Attributes["cpu.totalcompute"])
|
|
require.Nil(t, response.Resources) // defaults in cpu fingerprinter
|
|
require.Zero(t, response.NodeResources.Cpu) // defaults in cpu fingerprinter
|
|
}
|
|
|
|
func TestCPUFingerprint_AWS_InstanceNotFound(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
endpoint, cleanup := startFakeEC2Metadata(t, unknownInstanceType)
|
|
defer cleanup()
|
|
|
|
f := NewEnvAWSFingerprint(testlog.HCLogger(t))
|
|
f.(*EnvAWSFingerprint).endpoint = endpoint
|
|
|
|
node := &structs.Node{Attributes: make(map[string]string)}
|
|
|
|
request := &FingerprintRequest{Config: &config.Config{}, Node: node}
|
|
var response FingerprintResponse
|
|
err := f.Fingerprint(request, &response)
|
|
require.NoError(t, err)
|
|
require.True(t, response.Detected)
|
|
require.NotContains(t, response.Attributes, "cpu.modelname")
|
|
require.NotContains(t, response.Attributes, "cpu.frequency")
|
|
require.NotContains(t, response.Attributes, "cpu.numcores")
|
|
require.NotContains(t, response.Attributes, "cpu.totalcompute")
|
|
require.Nil(t, response.Resources)
|
|
require.Nil(t, response.NodeResources)
|
|
}
|
|
|
|
/// Utility functions for tests
|
|
|
|
func startFakeEC2Metadata(t *testing.T, endpoints []endpoint) (endpoint string, cleanup func()) {
|
|
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
for _, e := range endpoints {
|
|
if r.RequestURI == e.Uri {
|
|
w.Header().Set("Content-Type", e.ContentType)
|
|
fmt.Fprintln(w, e.Body)
|
|
}
|
|
}
|
|
}))
|
|
|
|
return ts.URL + "/latest", ts.Close
|
|
}
|
|
|
|
type routes struct {
|
|
Endpoints []*endpoint `json:"endpoints"`
|
|
}
|
|
|
|
type endpoint struct {
|
|
Uri string `json:"uri"`
|
|
ContentType string `json:"content-type"`
|
|
Body string `json:"body"`
|
|
}
|
|
|
|
// awsStubs mimics normal EC2 instance metadata
|
|
var awsStubs = []endpoint{
|
|
{
|
|
Uri: "/latest/meta-data/ami-id",
|
|
ContentType: "text/plain",
|
|
Body: "ami-1234",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/placement/availability-zone",
|
|
ContentType: "text/plain",
|
|
Body: "us-west-2a",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-id",
|
|
ContentType: "text/plain",
|
|
Body: "i-b3ba3875",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-life-cycle",
|
|
ContentType: "text/plain",
|
|
Body: "on-demand",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-type",
|
|
ContentType: "text/plain",
|
|
Body: "t3a.2xlarge",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/local-hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/local-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "10.0.0.207",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/public-hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ec2-54-191-117-175.us-west-2.compute.amazonaws.com",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/public-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "54.191.117.175",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/mac",
|
|
ContentType: "text/plain",
|
|
Body: "0a:20:d2:42:b3:55",
|
|
},
|
|
}
|
|
|
|
var unknownInstanceType = []endpoint{
|
|
{
|
|
Uri: "/latest/meta-data/ami-id",
|
|
ContentType: "text/plain",
|
|
Body: "ami-1234",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/placement/availability-zone",
|
|
ContentType: "text/plain",
|
|
Body: "us-west-2a",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-id",
|
|
ContentType: "text/plain",
|
|
Body: "i-b3ba3875",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-life-cycle",
|
|
ContentType: "text/plain",
|
|
Body: "on-demand",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-type",
|
|
ContentType: "text/plain",
|
|
Body: "xyz123.uber",
|
|
},
|
|
}
|
|
|
|
// noNetworkAWSStubs mimics an EC2 instance but without local ip address
|
|
// may happen in environments with odd EC2 Metadata emulation
|
|
var noNetworkAWSStubs = []endpoint{
|
|
{
|
|
Uri: "/latest/meta-data/ami-id",
|
|
ContentType: "text/plain",
|
|
Body: "ami-1234",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/placement/availability-zone",
|
|
ContentType: "text/plain",
|
|
Body: "us-west-2a",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-id",
|
|
ContentType: "text/plain",
|
|
Body: "i-b3ba3875",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-life-cycle",
|
|
ContentType: "text/plain",
|
|
Body: "on-demand",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-type",
|
|
ContentType: "text/plain",
|
|
Body: "m3.2xlarge",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/local-hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/local-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/public-hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ec2-54-191-117-175.us-west-2.compute.amazonaws.com",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/public-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "54.191.117.175",
|
|
},
|
|
}
|
|
|
|
// incompleteAWSImitationsStub mimics environments where some AWS endpoints
|
|
// return empty, namely Hetzner
|
|
var incompleteAWSImitationStubs = []endpoint{
|
|
{
|
|
Uri: "/latest/meta-data/hostname",
|
|
ContentType: "text/plain",
|
|
Body: "ip-10-0-0-207.us-west-2.compute.internal",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/instance-id",
|
|
ContentType: "text/plain",
|
|
Body: "i-b3ba3875",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/local-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "",
|
|
},
|
|
{
|
|
Uri: "/latest/meta-data/public-ipv4",
|
|
ContentType: "text/plain",
|
|
Body: "54.191.117.175",
|
|
},
|
|
}
|