+++ /dev/null
-package plugin
-
-import (
- "bytes"
- "crypto/sha256"
- "io"
- "io/ioutil"
- "net"
- "os"
- "path/filepath"
- "strings"
- "sync"
- "testing"
- "time"
-
- hclog "github.com/hashicorp/go-hclog"
-)
-
-func TestClient(t *testing.T) {
- process := helperProcess("mock")
- c := NewClient(&ClientConfig{Cmd: process, HandshakeConfig: testHandshake})
- defer c.Kill()
-
- // Test that it parses the proper address
- addr, err := c.Start()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- if addr.Network() != "tcp" {
- t.Fatalf("bad: %#v", addr)
- }
-
- if addr.String() != ":1234" {
- t.Fatalf("bad: %#v", addr)
- }
-
- // Test that it exits properly if killed
- c.Kill()
-
- if process.ProcessState == nil {
- t.Fatal("should have process state")
- }
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-// This tests a bug where Kill would start
-func TestClient_killStart(t *testing.T) {
- // Create a temporary dir to store the result file
- td, err := ioutil.TempDir("", "plugin")
- if err != nil {
- t.Fatalf("err: %s", err)
- }
- defer os.RemoveAll(td)
-
- // Start the client
- path := filepath.Join(td, "booted")
- process := helperProcess("bad-version", path)
- c := NewClient(&ClientConfig{Cmd: process, HandshakeConfig: testHandshake})
- defer c.Kill()
-
- // Verify our path doesn't exist
- if _, err := os.Stat(path); err == nil || !os.IsNotExist(err) {
- t.Fatalf("bad: %s", err)
- }
-
- // Test that it parses the proper address
- if _, err := c.Start(); err == nil {
- t.Fatal("expected error")
- }
-
- // Verify we started
- if _, err := os.Stat(path); err != nil {
- t.Fatalf("bad: %s", err)
- }
- if err := os.Remove(path); err != nil {
- t.Fatalf("bad: %s", err)
- }
-
- // Test that Kill does nothing really
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-
- if process.ProcessState == nil {
- t.Fatal("should have no process state")
- }
-
- // Verify our path doesn't exist
- if _, err := os.Stat(path); err == nil || !os.IsNotExist(err) {
- t.Fatalf("bad: %s", err)
- }
-}
-
-func TestClient_testCleanup(t *testing.T) {
- // Create a temporary dir to store the result file
- td, err := ioutil.TempDir("", "plugin")
- if err != nil {
- t.Fatalf("err: %s", err)
- }
- defer os.RemoveAll(td)
-
- // Create a path that the helper process will write on cleanup
- path := filepath.Join(td, "output")
-
- // Test the cleanup
- process := helperProcess("cleanup", path)
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
-
- // Grab the client so the process starts
- if _, err := c.Client(); err != nil {
- c.Kill()
- t.Fatalf("err: %s", err)
- }
-
- // Kill it gracefully
- c.Kill()
-
- // Test for the file
- if _, err := os.Stat(path); err != nil {
- t.Fatalf("err: %s", err)
- }
-}
-
-func TestClient_testInterface(t *testing.T) {
- process := helperProcess("test-interface")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer c.Kill()
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_grpc_servercrash(t *testing.T) {
- process := helperProcess("test-grpc")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- AllowedProtocols: []Protocol{ProtocolGRPC},
- })
- defer c.Kill()
-
- if _, err := c.Start(); err != nil {
- t.Fatalf("err: %s", err)
- }
-
- if v := c.Protocol(); v != ProtocolGRPC {
- t.Fatalf("bad: %s", v)
- }
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- _, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- c.process.Kill()
-
- select {
- case <-c.doneCtx.Done():
- case <-time.After(time.Second * 2):
- t.Fatal("Context was not closed")
- }
-}
-
-func TestClient_grpc(t *testing.T) {
- process := helperProcess("test-grpc")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- AllowedProtocols: []Protocol{ProtocolGRPC},
- })
- defer c.Kill()
-
- if _, err := c.Start(); err != nil {
- t.Fatalf("err: %s", err)
- }
-
- if v := c.Protocol(); v != ProtocolGRPC {
- t.Fatalf("bad: %s", v)
- }
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_grpcNotAllowed(t *testing.T) {
- process := helperProcess("test-grpc")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer c.Kill()
-
- if _, err := c.Start(); err == nil {
- t.Fatal("should error")
- }
-}
-
-func TestClient_cmdAndReattach(t *testing.T) {
- config := &ClientConfig{
- Cmd: helperProcess("start-timeout"),
- Reattach: &ReattachConfig{},
- }
-
- c := NewClient(config)
- defer c.Kill()
-
- _, err := c.Start()
- if err == nil {
- t.Fatal("err should not be nil")
- }
-}
-
-func TestClient_reattach(t *testing.T) {
- process := helperProcess("test-interface")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer c.Kill()
-
- // Grab the RPC client
- _, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Get the reattach configuration
- reattach := c.ReattachConfig()
-
- // Create a new client
- c = NewClient(&ClientConfig{
- Reattach: reattach,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_reattachNoProtocol(t *testing.T) {
- process := helperProcess("test-interface")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer c.Kill()
-
- // Grab the RPC client
- _, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Get the reattach configuration
- reattach := c.ReattachConfig()
- reattach.Protocol = ""
-
- // Create a new client
- c = NewClient(&ClientConfig{
- Reattach: reattach,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_reattachGRPC(t *testing.T) {
- process := helperProcess("test-grpc")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- AllowedProtocols: []Protocol{ProtocolGRPC},
- })
- defer c.Kill()
-
- // Grab the RPC client
- _, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Get the reattach configuration
- reattach := c.ReattachConfig()
-
- // Create a new client
- c = NewClient(&ClientConfig{
- Reattach: reattach,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- AllowedProtocols: []Protocol{ProtocolGRPC},
- })
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_reattachNotFound(t *testing.T) {
- // Find a bad pid
- var pid int = 5000
- for i := pid; i < 32000; i++ {
- if _, err := os.FindProcess(i); err != nil {
- pid = i
- break
- }
- }
-
- // Addr that won't work
- l, err := net.Listen("tcp", "127.0.0.1:0")
- if err != nil {
- t.Fatalf("err: %s", err)
- }
- addr := l.Addr()
- l.Close()
-
- // Reattach
- c := NewClient(&ClientConfig{
- Reattach: &ReattachConfig{
- Addr: addr,
- Pid: pid,
- },
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
-
- // Start shouldn't error
- if _, err := c.Start(); err == nil {
- t.Fatal("should error")
- } else if err != ErrProcessNotFound {
- t.Fatalf("err: %s", err)
- }
-}
-
-func TestClientStart_badVersion(t *testing.T) {
- config := &ClientConfig{
- Cmd: helperProcess("bad-version"),
- StartTimeout: 50 * time.Millisecond,
- HandshakeConfig: testHandshake,
- }
-
- c := NewClient(config)
- defer c.Kill()
-
- _, err := c.Start()
- if err == nil {
- t.Fatal("err should not be nil")
- }
-}
-
-func TestClient_Start_Timeout(t *testing.T) {
- config := &ClientConfig{
- Cmd: helperProcess("start-timeout"),
- StartTimeout: 50 * time.Millisecond,
- HandshakeConfig: testHandshake,
- }
-
- c := NewClient(config)
- defer c.Kill()
-
- _, err := c.Start()
- if err == nil {
- t.Fatal("err should not be nil")
- }
-}
-
-func TestClient_Stderr(t *testing.T) {
- stderr := new(bytes.Buffer)
- process := helperProcess("stderr")
- c := NewClient(&ClientConfig{
- Cmd: process,
- Stderr: stderr,
- HandshakeConfig: testHandshake,
- })
- defer c.Kill()
-
- if _, err := c.Start(); err != nil {
- t.Fatalf("err: %s", err)
- }
-
- for !c.Exited() {
- time.Sleep(10 * time.Millisecond)
- }
-
- if !strings.Contains(stderr.String(), "HELLO\n") {
- t.Fatalf("bad log data: '%s'", stderr.String())
- }
-
- if !strings.Contains(stderr.String(), "WORLD\n") {
- t.Fatalf("bad log data: '%s'", stderr.String())
- }
-}
-
-func TestClient_StderrJSON(t *testing.T) {
- stderr := new(bytes.Buffer)
- process := helperProcess("stderr-json")
- c := NewClient(&ClientConfig{
- Cmd: process,
- Stderr: stderr,
- HandshakeConfig: testHandshake,
- })
- defer c.Kill()
-
- if _, err := c.Start(); err != nil {
- t.Fatalf("err: %s", err)
- }
-
- for !c.Exited() {
- time.Sleep(10 * time.Millisecond)
- }
-
- if !strings.Contains(stderr.String(), "[\"HELLO\"]\n") {
- t.Fatalf("bad log data: '%s'", stderr.String())
- }
-
- if !strings.Contains(stderr.String(), "12345\n") {
- t.Fatalf("bad log data: '%s'", stderr.String())
- }
-}
-
-func TestClient_Stdin(t *testing.T) {
- // Overwrite stdin for this test with a temporary file
- tf, err := ioutil.TempFile("", "terraform")
- if err != nil {
- t.Fatalf("err: %s", err)
- }
- defer os.Remove(tf.Name())
- defer tf.Close()
-
- if _, err = tf.WriteString("hello"); err != nil {
- t.Fatalf("error: %s", err)
- }
-
- if err = tf.Sync(); err != nil {
- t.Fatalf("error: %s", err)
- }
-
- if _, err = tf.Seek(0, 0); err != nil {
- t.Fatalf("error: %s", err)
- }
-
- oldStdin := os.Stdin
- defer func() { os.Stdin = oldStdin }()
- os.Stdin = tf
-
- process := helperProcess("stdin")
- c := NewClient(&ClientConfig{Cmd: process, HandshakeConfig: testHandshake})
- defer c.Kill()
-
- _, err = c.Start()
- if err != nil {
- t.Fatalf("error: %s", err)
- }
-
- for {
- if c.Exited() {
- break
- }
-
- time.Sleep(50 * time.Millisecond)
- }
-
- if !process.ProcessState.Success() {
- t.Fatal("process didn't exit cleanly")
- }
-}
-
-func TestClient_SecureConfig(t *testing.T) {
- // Test failure case
- secureConfig := &SecureConfig{
- Checksum: []byte{'1'},
- Hash: sha256.New(),
- }
- process := helperProcess("test-interface")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- SecureConfig: secureConfig,
- })
-
- // Grab the RPC client, should error
- _, err := c.Client()
- c.Kill()
- if err != ErrChecksumsDoNotMatch {
- t.Fatalf("err should be %s, got %s", ErrChecksumsDoNotMatch, err)
- }
-
- // Get the checksum of the executable
- file, err := os.Open(os.Args[0])
- if err != nil {
- t.Fatal(err)
- }
- defer file.Close()
-
- hash := sha256.New()
-
- _, err = io.Copy(hash, file)
- if err != nil {
- t.Fatal(err)
- }
-
- sum := hash.Sum(nil)
-
- secureConfig = &SecureConfig{
- Checksum: sum,
- Hash: sha256.New(),
- }
-
- c = NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- SecureConfig: secureConfig,
- })
- defer c.Kill()
-
- // Grab the RPC client
- _, err = c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-}
-
-func TestClient_TLS(t *testing.T) {
- // Test failure case
- process := helperProcess("test-interface-tls")
- cBad := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer cBad.Kill()
-
- // Grab the RPC client
- clientBad, err := cBad.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := clientBad.Dispense("test")
- if err == nil {
- t.Fatal("expected error, got nil")
- }
-
- cBad.Kill()
-
- // Add TLS config to client
- tlsConfig, err := helperTLSProvider()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- process = helperProcess("test-interface-tls")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- TLSConfig: tlsConfig,
- })
- defer c.Kill()
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err = client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_TLS_grpc(t *testing.T) {
- // Add TLS config to client
- tlsConfig, err := helperTLSProvider()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- process := helperProcess("test-grpc-tls")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- TLSConfig: tlsConfig,
- AllowedProtocols: []Protocol{ProtocolGRPC},
- })
- defer c.Kill()
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- result := impl.Double(21)
- if result != 42 {
- t.Fatalf("bad: %#v", result)
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
-
-func TestClient_secureConfigAndReattach(t *testing.T) {
- config := &ClientConfig{
- SecureConfig: &SecureConfig{},
- Reattach: &ReattachConfig{},
- }
-
- c := NewClient(config)
- defer c.Kill()
-
- _, err := c.Start()
- if err != ErrSecureConfigAndReattach {
- t.Fatalf("err should not be %s, got %s", ErrSecureConfigAndReattach, err)
- }
-}
-
-func TestClient_ping(t *testing.T) {
- process := helperProcess("test-interface")
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- })
- defer c.Kill()
-
- // Get the client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err: %s", err)
- }
-
- // Ping, should work
- if err := client.Ping(); err != nil {
- t.Fatalf("err: %s", err)
- }
-
- // Kill it
- c.Kill()
- if err := client.Ping(); err == nil {
- t.Fatal("should error")
- }
-}
-
-func TestClient_logger(t *testing.T) {
- t.Run("net/rpc", func(t *testing.T) { testClient_logger(t, "netrpc") })
- t.Run("grpc", func(t *testing.T) { testClient_logger(t, "grpc") })
-}
-
-func testClient_logger(t *testing.T, proto string) {
- var buffer bytes.Buffer
- mutex := new(sync.Mutex)
- stderr := io.MultiWriter(os.Stderr, &buffer)
- // Custom hclog.Logger
- clientLogger := hclog.New(&hclog.LoggerOptions{
- Name: "test-logger",
- Level: hclog.Trace,
- Output: stderr,
- Mutex: mutex,
- })
-
- process := helperProcess("test-interface-logger-" + proto)
- c := NewClient(&ClientConfig{
- Cmd: process,
- HandshakeConfig: testHandshake,
- Plugins: testPluginMap,
- Logger: clientLogger,
- AllowedProtocols: []Protocol{ProtocolNetRPC, ProtocolGRPC},
- })
- defer c.Kill()
-
- // Grab the RPC client
- client, err := c.Client()
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- // Grab the impl
- raw, err := client.Dispense("test")
- if err != nil {
- t.Fatalf("err should be nil, got %s", err)
- }
-
- impl, ok := raw.(testInterface)
- if !ok {
- t.Fatalf("bad: %#v", raw)
- }
-
- {
- // Discard everything else, and capture the output we care about
- mutex.Lock()
- buffer.Reset()
- mutex.Unlock()
- impl.PrintKV("foo", "bar")
- time.Sleep(100 * time.Millisecond)
- mutex.Lock()
- line, err := buffer.ReadString('\n')
- mutex.Unlock()
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(line, "foo=bar") {
- t.Fatalf("bad: %q", line)
- }
- }
-
- {
- // Try an integer type
- mutex.Lock()
- buffer.Reset()
- mutex.Unlock()
- impl.PrintKV("foo", 12)
- time.Sleep(100 * time.Millisecond)
- mutex.Lock()
- line, err := buffer.ReadString('\n')
- mutex.Unlock()
- if err != nil {
- t.Fatal(err)
- }
- if !strings.Contains(line, "foo=12") {
- t.Fatalf("bad: %q", line)
- }
- }
-
- // Kill it
- c.Kill()
-
- // Test that it knows it is exited
- if !c.Exited() {
- t.Fatal("should say client has exited")
- }
-}
OSDN Git Service
