terraform/backend/remote-state/consul/client_test.go

package consul

import (
	"context"
	"fmt"
	"net"
	"sync"
	"testing"
	"time"

	"github.com/hashicorp/terraform/backend"
	"github.com/hashicorp/terraform/states/remote"
	"github.com/hashicorp/terraform/states/statemgr"
)

func TestRemoteClient_impl(t *testing.T) {
	var _ remote.Client = new(RemoteClient)
	var _ remote.ClientLocker = new(RemoteClient)
}

func TestRemoteClient(t *testing.T) {
	testCases := []string{
		fmt.Sprintf("tf-unit/%s", time.Now().String()),
		fmt.Sprintf("tf-unit/%s/", time.Now().String()),
	}

	for _, path := range testCases {
		t.Run(path, func(*testing.T) {
			// Get the backend
			b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
				"address": srv.HTTPAddr,
				"path":    path,
			}))

			// Grab the client
			state, err := b.StateMgr(backend.DefaultStateName)
			if err != nil {
				t.Fatalf("err: %s", err)
			}

			// Test
			remote.TestClient(t, state.(*remote.State).Client)
		})
	}
}

// test the gzip functionality of the client
func TestRemoteClient_gzipUpgrade(t *testing.T) {
	statePath := fmt.Sprintf("tf-unit/%s", time.Now().String())

	// Get the backend
	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
		"address": srv.HTTPAddr,
		"path":    statePath,
	}))

	// Grab the client
	state, err := b.StateMgr(backend.DefaultStateName)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// Test
	remote.TestClient(t, state.(*remote.State).Client)

	// create a new backend with gzip
	b = backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
		"address": srv.HTTPAddr,
		"path":    statePath,
		"gzip":    true,
	}))

	// Grab the client
	state, err = b.StateMgr(backend.DefaultStateName)
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// Test
	remote.TestClient(t, state.(*remote.State).Client)
}

func TestConsul_stateLock(t *testing.T) {
	testCases := []string{
		fmt.Sprintf("tf-unit/%s", time.Now().String()),
		fmt.Sprintf("tf-unit/%s/", time.Now().String()),
	}

	for _, path := range testCases {
		t.Run(path, func(*testing.T) {
			// create 2 instances to get 2 remote.Clients
			sA, err := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
				"address": srv.HTTPAddr,
				"path":    path,
			})).StateMgr(backend.DefaultStateName)
			if err != nil {
				t.Fatal(err)
			}

			sB, err := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
				"address": srv.HTTPAddr,
				"path":    path,
			})).StateMgr(backend.DefaultStateName)
			if err != nil {
				t.Fatal(err)
			}

			remote.TestRemoteLocks(t, sA.(*remote.State).Client, sB.(*remote.State).Client)
		})
	}
}

func TestConsul_destroyLock(t *testing.T) {
	testCases := []string{
		fmt.Sprintf("tf-unit/%s", time.Now().String()),
		fmt.Sprintf("tf-unit/%s/", time.Now().String()),
	}

	for _, path := range testCases {
		t.Run(path, func(*testing.T) {
			// Get the backend
			b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
				"address": srv.HTTPAddr,
				"path":    path,
			}))

			// Grab the client
			s, err := b.StateMgr(backend.DefaultStateName)
			if err != nil {
				t.Fatalf("err: %s", err)
			}

			c := s.(*remote.State).Client.(*RemoteClient)

			info := statemgr.NewLockInfo()
			id, err := c.Lock(info)
			if err != nil {
				t.Fatal(err)
			}

			lockPath := c.Path + lockSuffix

			if err := c.Unlock(id); err != nil {
				t.Fatal(err)
			}

			// get the lock val
			pair, _, err := c.Client.KV().Get(lockPath, nil)
			if err != nil {
				t.Fatal(err)
			}
			if pair != nil {
				t.Fatalf("lock key not cleaned up at: %s", pair.Key)
			}
		})
	}
}

func TestConsul_lostLock(t *testing.T) {
	path := fmt.Sprintf("tf-unit/%s", time.Now().String())

	// create 2 instances to get 2 remote.Clients
	sA, err := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
		"address": srv.HTTPAddr,
		"path":    path,
	})).StateMgr(backend.DefaultStateName)
	if err != nil {
		t.Fatal(err)
	}

	sB, err := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
		"address": srv.HTTPAddr,
		"path":    path + "-not-used",
	})).StateMgr(backend.DefaultStateName)
	if err != nil {
		t.Fatal(err)
	}

	info := statemgr.NewLockInfo()
	info.Operation = "test-lost-lock"
	id, err := sA.Lock(info)
	if err != nil {
		t.Fatal(err)
	}

	reLocked := make(chan struct{})
	testLockHook = func() {
		close(reLocked)
		testLockHook = nil
	}

	// now we use the second client to break the lock
	kv := sB.(*remote.State).Client.(*RemoteClient).Client.KV()
	_, err = kv.Delete(path+lockSuffix, nil)
	if err != nil {
		t.Fatal(err)
	}

	<-reLocked

	if err := sA.Unlock(id); err != nil {
		t.Fatal(err)
	}
}

func TestConsul_lostLockConnection(t *testing.T) {
	// create an "unreliable" network by closing all the consul client's
	// network connections
	conns := &unreliableConns{}
	origDialFn := dialContext
	defer func() {
		dialContext = origDialFn
	}()
	dialContext = conns.DialContext

	path := fmt.Sprintf("tf-unit/%s", time.Now().String())

	b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{
		"address": srv.HTTPAddr,
		"path":    path,
	}))

	s, err := b.StateMgr(backend.DefaultStateName)
	if err != nil {
		t.Fatal(err)
	}

	info := statemgr.NewLockInfo()
	info.Operation = "test-lost-lock-connection"
	id, err := s.Lock(info)
	if err != nil {
		t.Fatal(err)
	}

	// kill the connection a few times
	for i := 0; i < 3; i++ {
		dialed := conns.dialedDone()
		// kill any open connections
		conns.Kill()
		// wait for a new connection to be dialed, and kill it again
		<-dialed
	}

	if err := s.Unlock(id); err != nil {
		t.Fatal("unlock error:", err)
	}
}

type unreliableConns struct {
	sync.Mutex
	conns        []net.Conn
	dialCallback func()
}

func (u *unreliableConns) DialContext(ctx context.Context, netw, addr string) (net.Conn, error) {
	u.Lock()
	defer u.Unlock()

	dialer := &net.Dialer{}
	conn, err := dialer.DialContext(ctx, netw, addr)
	if err != nil {
		return nil, err
	}

	u.conns = append(u.conns, conn)

	if u.dialCallback != nil {
		u.dialCallback()
	}

	return conn, nil
}

func (u *unreliableConns) dialedDone() chan struct{} {
	u.Lock()
	defer u.Unlock()
	dialed := make(chan struct{})
	u.dialCallback = func() {
		defer close(dialed)
		u.dialCallback = nil
	}

	return dialed
}

// Kill these with a deadline, just to make sure we don't end up with any EOFs
// that get ignored.
func (u *unreliableConns) Kill() {
	u.Lock()
	defer u.Unlock()

	for _, conn := range u.conns {
		conn.(*net.TCPConn).SetDeadline(time.Now())
	}
	u.conns = nil
}