func TestCommandRun_advertiseAddr(t *testing.T) {
doneCh := make(chan struct{})
shutdownCh := make(chan struct{})
defer func() {
close(shutdownCh)
<-doneCh
}()
c := &Command{
ShutdownCh: shutdownCh,
Ui: new(cli.MockUi),
}
rpcAddr := getRPCAddr()
args := []string{
"-bind", testutil.GetBindAddr().String(),
"-rpc-addr", rpcAddr,
"-advertise", "127.0.0.10:12345",
}
go func() {
code := c.Run(args)
if code != 0 {
log.Printf("bad: %d", code)
}
close(doneCh)
}()
testutil.Yield()
client, err := client.NewRPCClient(rpcAddr)
if err != nil {
t.Fatalf("err: %s", err)
}
defer client.Close()
members, err := client.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(members) != 1 {
t.Fatalf("bad: %#v", members)
}
// Check the addr and port is as advertised!
m := members[0]
if bytes.Compare(m.Addr, []byte{127, 0, 0, 10}) != 0 {
t.Fatalf("bad: %#v", m)
}
if m.Port != 12345 {
t.Fatalf("bad: %#v", m)
}
}
func clusterUp(clusterAddr string) (*client.RPCClient, error) {
client, err := client.NewRPCClient(clusterAddr)
if err != nil {
return nil, err
}
_, err = client.Join([]string{clusterAddr}, false)
if err != nil {
return nil, err
}
return client, nil
}
func NewCluster(host string) (Cluster, error) {
//"127.0.0.1:7373"
s, err := client.NewRPCClient(host)
if err != nil {
fmt.Println(err)
return Cluster{}, err
}
c := Cluster{
serf: s,
}
return c, nil
}
func TestTagsCommandRun(t *testing.T) {
a1 := testAgent(t)
defer a1.Shutdown()
rpcAddr, ipc := testIPC(t, a1)
defer ipc.Shutdown()
ui := new(cli.MockUi)
c := &TagsCommand{Ui: ui}
args := []string{
"-rpc-addr=" + rpcAddr,
"-delete", "tag2",
"-set", "a=1",
"-set", "b=2",
}
code := c.Run(args)
if code != 0 {
t.Fatalf("bad: %d. %#v", code, ui.ErrorWriter.String())
}
if !strings.Contains(ui.OutputWriter.String(), "Successfully updated agent tags") {
t.Fatalf("bad: %#v", ui.OutputWriter.String())
}
rpcClient, err := client.NewRPCClient(rpcAddr)
if err != nil {
t.Fatalf("err: %s", err)
}
mem, err := rpcClient.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(mem) != 1 {
t.Fatalf("bad: %v", mem)
}
m0 := mem[0]
if _, ok := m0.Tags["tag2"]; ok {
t.Fatalf("bad: %v", m0.Tags)
}
if _, ok := m0.Tags["a"]; !ok {
t.Fatalf("bad: %v", m0.Tags)
}
if _, ok := m0.Tags["b"]; !ok {
t.Fatalf("bad: %v", m0.Tags)
}
}
func TestCommandRun_rpc(t *testing.T) {
doneCh := make(chan struct{})
shutdownCh := make(chan struct{})
defer func() {
close(shutdownCh)
<-doneCh
}()
c := &Command{
ShutdownCh: shutdownCh,
Ui: new(cli.MockUi),
}
rpcAddr := getRPCAddr()
args := []string{
"-bind", testutil.GetBindAddr().String(),
"-rpc-addr", rpcAddr,
}
go func() {
code := c.Run(args)
if code != 0 {
log.Printf("bad: %d", code)
}
close(doneCh)
}()
testutil.Yield()
client, err := client.NewRPCClient(rpcAddr)
if err != nil {
t.Fatalf("err: %s", err)
}
defer client.Close()
members, err := client.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(members) != 1 {
t.Fatalf("bad: %#v", members)
}
}
func TestKeysCommandRun_InstallKey(t *testing.T) {
a1 := testKeysCommandAgent(t)
defer a1.Shutdown()
rpcAddr, ipc := testIPC(t, a1)
defer ipc.Shutdown()
ui := new(cli.MockUi)
c := &KeysCommand{Ui: ui}
rpcClient, err := client.NewRPCClient(rpcAddr)
if err != nil {
t.Fatalf("err: %s", err)
}
keys, _, err := rpcClient.ListKeys()
if err != nil {
t.Fatalf("err: %s", err)
}
if _, ok := keys["jbuQMI4gMUeh1PPmKOtiBg=="]; ok {
t.Fatalf("have test key")
}
args := []string{
"-rpc-addr=" + rpcAddr,
"-install", "jbuQMI4gMUeh1PPmKOtiBg==",
}
code := c.Run(args)
if code != 0 {
t.Fatalf("bad: %d. %#v", code, ui.ErrorWriter.String())
}
if !strings.Contains(ui.OutputWriter.String(), "Successfully installed key") {
t.Fatalf("bad: %#v", ui.OutputWriter.String())
}
keys, _, err = rpcClient.ListKeys()
if err != nil {
t.Fatalf("err: %s", err)
}
if _, ok := keys["jbuQMI4gMUeh1PPmKOtiBg=="]; !ok {
t.Fatalf("new key not found")
}
}
// StartSerfin sets up the serf instance and starts listening for events and
// queries from other serf instances.
func StartSerfin() error {
var err error
Serfer, err = serfclient.NewRPCClient(config.Config.SerfAddr)
if err != nil {
logger.Criticalf(err.Error())
os.Exit(1)
}
if config.Config.SerfEventAnnounce {
err = Serfer.UserEvent("goiardi-join", []byte(config.Config.Hostname), true)
if err != nil {
logger.Criticalf(err.Error())
os.Exit(1)
}
}
return nil
}
// testRPCClient returns an RPCClient connected to an RPC server that
// serves only this connection.
func testRPCClient(t *testing.T) (*client.RPCClient, *Agent, *AgentIPC) {
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("err: %s", err)
}
lw := NewLogWriter(512)
mult := io.MultiWriter(os.Stderr, lw)
agent := testAgent(mult)
ipc := NewAgentIPC(agent, "", l, mult, lw)
rpcClient, err := client.NewRPCClient(l.Addr().String())
if err != nil {
t.Fatalf("err: %s", err)
}
return rpcClient, agent, ipc
}
func TestCommandRun_mDNS(t *testing.T) {
// mDNS does not work in travis
if os.Getenv("TRAVIS") != "" {
t.SkipNow()
}
// Start an agent
doneCh := make(chan struct{})
shutdownCh := make(chan struct{})
defer func() {
close(shutdownCh)
<-doneCh
}()
c := &Command{
ShutdownCh: shutdownCh,
Ui: new(cli.MockUi),
}
args := []string{
"-node", "foo",
"-bind", testutil.GetBindAddr().String(),
"-discover", "test",
"-rpc-addr", getRPCAddr(),
}
go func() {
code := c.Run(args)
if code != 0 {
log.Printf("bad: %d", code)
}
close(doneCh)
}()
// Start a second agent
doneCh2 := make(chan struct{})
shutdownCh2 := make(chan struct{})
defer func() {
close(shutdownCh2)
<-doneCh2
}()
c2 := &Command{
ShutdownCh: shutdownCh2,
Ui: new(cli.MockUi),
}
addr2 := getRPCAddr()
args2 := []string{
"-node", "bar",
"-bind", testutil.GetBindAddr().String(),
"-discover", "test",
"-rpc-addr", addr2,
}
go func() {
code := c2.Run(args2)
if code != 0 {
log.Printf("bad: %d", code)
}
close(doneCh2)
}()
time.Sleep(150 * time.Millisecond)
client, err := client.NewRPCClient(addr2)
if err != nil {
t.Fatalf("err: %s", err)
}
defer client.Close()
members, err := client.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(members) != 2 {
t.Fatalf("bad: %#v", members)
}
}
func TestKeysCommandRun_RemoveKey(t *testing.T) {
a1 := testKeysCommandAgent(t)
defer a1.Shutdown()
rpcAddr, ipc := testIPC(t, a1)
defer ipc.Shutdown()
ui := new(cli.MockUi)
c := &KeysCommand{Ui: ui}
rpcClient, err := client.NewRPCClient(rpcAddr)
if err != nil {
t.Fatalf("err: %s", err)
}
keys, _, err := rpcClient.ListKeys()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(keys) != 2 {
t.Fatalf("expected 2 keys: %v", keys)
}
// Removing non-existing key still returns 0 (noop)
args := []string{
"-rpc-addr=" + rpcAddr,
"-remove", "eodFZZjm7pPwIZ0Miy7boQ==",
}
code := c.Run(args)
if code != 0 {
t.Fatalf("bad: %d. %#v", code, ui.ErrorWriter.String())
}
// Number of keys unchanged after noop command
keys, _, err = rpcClient.ListKeys()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(keys) != 2 {
t.Fatalf("expected 2 keys: %v", keys)
}
// Removing a primary key returns 1
args = []string{
"-rpc-addr=" + rpcAddr,
"-remove", "SNCg1bQSoCdGVlEx+TgfBw==",
}
ui.ErrorWriter.Reset()
code = c.Run(args)
if code != 1 {
t.Fatalf("bad: %d. %#v", code, ui.ErrorWriter.String())
}
if !strings.Contains(ui.ErrorWriter.String(), "Error removing key") {
t.Fatalf("bad: %#v", ui.OutputWriter.String())
}
// Removing a non-primary, existing key returns 0
args = []string{
"-rpc-addr=" + rpcAddr,
"-remove", "vbitCcJNwNP4aEWHgofjMg==",
}
code = c.Run(args)
if code != 0 {
t.Fatalf("bad: %d. %#v", code, ui.ErrorWriter.String())
}
// Key removed after successful -remove command
keys, _, err = rpcClient.ListKeys()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(keys) != 1 {
t.Fatalf("expected 2 keys: %v", keys)
}
}
// RPCClient returns a new Serf RPC client with the given address.
func RPCClient(addr string) (*client.RPCClient, error) {
return client.NewRPCClient(addr)
}