| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package ipc |
| |
| import ( |
| "flag" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "net" |
| "os" |
| "path/filepath" |
| "runtime" |
| "strings" |
| "syscall" |
| "testing" |
| "time" |
| |
| "v.io/v23/vom" |
| "v.io/x/lib/vlog" |
| "v.io/x/ref/services/agent" |
| ) |
| |
| type echo int |
| |
| func (e echo) Echo(m string) (string, error) { |
| return m, nil |
| } |
| |
| type delayedEcho struct { |
| gotA, gotB chan struct{} |
| doneA, doneB chan string |
| } |
| |
| func newDelayedEcho() delayedEcho { |
| return delayedEcho{make(chan struct{}, 1), make(chan struct{}, 1), make(chan string, 1), make(chan string, 1)} |
| } |
| |
| func (d delayedEcho) EchoA() (string, error) { |
| close(d.gotA) |
| return <-d.doneA, nil |
| } |
| |
| func (d delayedEcho) EchoB(prefix string) (string, error) { |
| close(d.gotB) |
| return prefix + <-d.doneB, nil |
| } |
| |
| type returnError int |
| |
| func (returnError) BreakMe(a, b string) (int, error) { |
| return 0, fmt.Errorf("%s %s", a, b) |
| } |
| |
| type tunnel struct { |
| ipc *IPC |
| } |
| |
| func (t *tunnel) Tunnel() (str string, err error) { |
| conn := t.ipc.Connections()[0] |
| err = conn.Call("Echo", []interface{}{"Tunnel"}, &str) |
| return |
| } |
| |
| func newServer(t *testing.T, servers ...interface{}) (ipc *IPC, path string, f func()) { |
| dir, err := ioutil.TempDir("", "sock") |
| if err != nil { |
| t.Fatal(err) |
| } |
| path = filepath.Join(dir, "sock") |
| ipc = NewIPC() |
| for _, s := range servers { |
| if err := ipc.Serve(s); err != nil { |
| t.Fatal(err) |
| } |
| } |
| if err := ipc.Listen(path); err != nil { |
| os.RemoveAll(dir) |
| t.Fatal(err) |
| } |
| return ipc, path, func() { ipc.Close(); os.RemoveAll(dir) } |
| } |
| |
| func isEpipe(err error) bool { |
| for operr, ok := err.(*net.OpError); ok; operr, ok = err.(*net.OpError) { |
| err = operr.Err |
| } |
| return err == syscall.EPIPE |
| } |
| |
| func TestDoubleServe(t *testing.T) { |
| ipc := NewIPC() |
| var a echo |
| var b echo |
| if err := ipc.Serve(a); err != nil { |
| t.Fatal(err) |
| } |
| if err := ipc.Serve(b); err == nil { |
| t.Fatal("Expected error") |
| } |
| } |
| |
| func TestListen(t *testing.T) { |
| ipc1, path, cleanup := newServer(t) |
| defer cleanup() |
| if stat, err := os.Stat(path); err == nil { |
| if stat.Mode()&os.ModeSocket == 0 { |
| t.Fatalf("Not a socket: %#o", stat.Mode()) |
| } |
| } else { |
| t.Fatal(err) |
| } |
| ipc1.Close() |
| if _, err := os.Stat(path); !os.IsNotExist(err) { |
| t.Fatalf("Expected NotExist, got %v", err) |
| } |
| } |
| |
| func TestBadConnect(t *testing.T) { |
| t.Skip() |
| timeA := time.Now() |
| ipc, path, cleanup := newServer(t) |
| timeB := time.Now() |
| if got := ipc.IdleStartTime(); got.Before(timeA) || got.After(timeB) { |
| t.Fatalf("Wanted time between %v and %v, got %v instead", timeA, timeB, got) |
| } |
| defer cleanup() |
| conn, err := net.Dial("unix", path) |
| if err != nil { |
| t.Fatal(err) |
| } |
| enc := vom.NewEncoder(conn) |
| dec := vom.NewDecoder(conn) |
| |
| var theirInfo agent.ConnInfo |
| if err = dec.Decode(&theirInfo); err != nil { |
| t.Fatal(err) |
| } |
| if got := ipc.IdleStartTime(); !got.IsZero() { |
| t.Fatalf("Wanted zero time, got %v instead", got) |
| } |
| |
| timeA = time.Now() |
| if err = enc.Encode(agent.RpcMessageReq{Value: agent.RpcRequest{Id: 0, Method: "foo", NumArgs: 0}}); err != nil { |
| if !isEpipe(err) { |
| // The server will close the connection when it gets |
| // bad data. If that happens fast enough we get EPIPE. |
| t.Fatal(err) |
| } |
| } |
| var response agent.RpcMessage |
| if err = dec.Decode(&response); err != io.EOF { |
| t.Fatalf("Expected eof, got %v", err) |
| } |
| conn.Close() |
| // Give a chance for the ipc object to observe the connection closure. |
| for len(ipc.Connections()) > 0 { |
| runtime.Gosched() |
| } |
| timeB = time.Now() |
| if got := ipc.IdleStartTime(); got.Before(timeA) || got.After(timeB) { |
| t.Fatalf("Wanted time between %v and %v, got %v instead", timeA, timeB, got) |
| } |
| } |
| |
| func TestBadMinVersion(t *testing.T) { |
| _, path, cleanup := newServer(t) |
| defer cleanup() |
| conn, err := net.Dial("unix", path) |
| if err != nil { |
| t.Fatal(err) |
| } |
| enc := vom.NewEncoder(conn) |
| dec := vom.NewDecoder(conn) |
| |
| var info agent.ConnInfo |
| if err = dec.Decode(&info); err != nil { |
| t.Fatal(err) |
| } |
| |
| info.MaxVersion++ |
| info.MinVersion = info.MaxVersion |
| if err = enc.Encode(info); err != nil { |
| t.Fatal(err) |
| } |
| |
| var response agent.RpcMessage |
| if err = dec.Decode(&response); err != io.EOF { |
| t.Fatalf("Expected EOF, got %v", err) |
| } |
| } |
| |
| func TestBadMaxVersion(t *testing.T) { |
| _, path, cleanup := newServer(t) |
| defer cleanup() |
| conn, err := net.Dial("unix", path) |
| if err != nil { |
| t.Fatal(err) |
| } |
| enc := vom.NewEncoder(conn) |
| dec := vom.NewDecoder(conn) |
| |
| var info agent.ConnInfo |
| if err = dec.Decode(&info); err != nil { |
| t.Fatal(err) |
| } |
| |
| info.MinVersion-- |
| info.MaxVersion = info.MinVersion |
| if err = enc.Encode(info); err != nil { |
| t.Fatal(err) |
| } |
| |
| var response agent.RpcMessage |
| if err = dec.Decode(&response); err != io.EOF { |
| t.Fatalf("Expected EOF, got %v", err) |
| } |
| } |
| |
| func TestEcho(t *testing.T) { |
| var e echo |
| _, path, cleanup := newServer(t, e) |
| defer cleanup() |
| |
| ipc2 := NewIPC() |
| defer ipc2.Close() |
| client, err := ipc2.Connect(path, 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var result string |
| err = client.Call("Echo", []interface{}{"hello"}, &result) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != "hello" { |
| t.Fatalf("Expected hello, got %q", result) |
| } |
| } |
| |
| func TestOutOfOrder(t *testing.T) { |
| delay := newDelayedEcho() |
| _, path, cleanup := newServer(t, delay) |
| defer cleanup() |
| |
| ipc2 := NewIPC() |
| defer ipc2.Close() |
| client, err := ipc2.Connect(path, 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var resultA string |
| errA := make(chan error) |
| go func() { errA <- client.Call("EchoA", nil, &resultA) }() |
| <-delay.gotA |
| |
| delay.doneB <- " world" |
| var resultB string |
| err = client.Call("EchoB", []interface{}{"hello"}, &resultB) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if resultB != "hello world" { |
| t.Fatalf("Expected 'hello word', got %q", resultB) |
| } |
| delay.doneA <- "foobar" |
| if err := <-errA; err != nil { |
| t.Fatal(err) |
| } |
| if resultA != "foobar" { |
| t.Fatalf("Expected foobar, got %q", resultA) |
| } |
| |
| } |
| |
| func TestErrorReturn(t *testing.T) { |
| var s returnError |
| _, path, cleanup := newServer(t, s) |
| defer cleanup() |
| |
| ipc2 := NewIPC() |
| defer ipc2.Close() |
| client, err := ipc2.Connect(path, 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var result int |
| err = client.Call("BreakMe", []interface{}{"oh", "no"}, &result) |
| if err == nil { |
| t.Fatalf("Expected error, got %d", result) |
| } |
| if !strings.HasSuffix(err.Error(), "oh no") { |
| t.Fatalf("Expected 'oh no', got %q", err.Error()) |
| } |
| } |
| |
| func TestBidi(t *testing.T) { |
| s := &tunnel{} |
| ipc1, path, cleanup := newServer(t, s) |
| defer cleanup() |
| s.ipc = ipc1 |
| |
| ipc2 := NewIPC() |
| defer ipc2.Close() |
| |
| var e echo |
| ipc2.Serve(e) |
| client, err := ipc2.Connect(path, 0) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var result string |
| err = client.Call("Tunnel", nil, &result) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != "Tunnel" { |
| t.Fatalf("Expected Tunnel, got %q", result) |
| } |
| } |
| |
| func TestMain(m *testing.M) { |
| flag.Parse() |
| vlog.ConfigureLibraryLoggerFromFlags() |
| os.Exit(m.Run()) |
| } |
