func TestRPCClientUpdateTags(t *testing.T) {
client, a1, ipc := testRPCClient(t)
defer ipc.Shutdown()
defer client.Close()
defer a1.Shutdown()
if err := a1.Start(); err != nil {
t.Fatalf("err: %s", err)
}
testutil.Yield()
mem, err := client.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["testing"]; ok {
t.Fatalf("have testing tag")
}
if err := client.UpdateTags(map[string]string{"testing": "1"}, nil); err != nil {
t.Fatalf("err: %s", err)
}
mem, err = client.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["testing"]; !ok {
t.Fatalf("missing testing tag")
}
}
func TestRPCClientMembers(t *testing.T) {
client, a1, ipc := testRPCClient(t)
a2 := testAgent(nil)
defer ipc.Shutdown()
defer client.Close()
defer a1.Shutdown()
defer a2.Shutdown()
if err := a1.Start(); err != nil {
t.Fatalf("err: %s", err)
}
if err := a2.Start(); err != nil {
t.Fatalf("err: %s", err)
}
testutil.Yield()
mem, err := client.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(mem) != 1 {
t.Fatalf("bad: %#v", mem)
}
_, err = client.Join([]string{a2.conf.MemberlistConfig.BindAddr}, false)
if err != nil {
t.Fatalf("err: %s", err)
}
testutil.Yield()
mem, err = client.Members()
if err != nil {
t.Fatalf("err: %s", err)
}
if len(mem) != 2 {
t.Fatalf("bad: %#v", mem)
}
}
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 (c MemberContainer) String() string {
var result []string
for _, member := range c.Members {
// Format the tags as tag1=v1,tag2=v2,...
var tagPairs []string
for name, value := range member.Tags {
tagPairs = append(tagPairs, fmt.Sprintf("%s=%s", name, value))
}
tags := strings.Join(tagPairs, ",")
line := fmt.Sprintf("%s|%s|%s|%s",
member.Name, member.Addr, member.Status, tags)
result = append(result, line)
}
output, _ := columnize.SimpleFormat(result)
return output
}
*/
func getAllMembers() {
addr := "127.0.0.1:7373"
client, err := RPCClient(addr)
//client, err := RPCClient(*rpcAddr)
if err != nil {
fmt.Sprintf("Error connecting to Serf agent: %s", err)
return
}
defer client.Close()
members, err := client.Members()
if err != nil {
if debug {
log.Println("Error retrieving members: %s", err)
}
return
}
//fmt.Println(members)
result := MemberContainer{}
for _, member := range members {
addr := net.TCPAddr{IP: member.Addr, Port: int(member.Port)}
result.Members = append(result.Members, Member{
Name: member.Name,
Addr: addr.String(),
Port: member.Port,
Tags: member.Tags,
Status: member.Status,
Proto: map[string]uint8{
"min": member.DelegateMin,
"max": member.DelegateMax,
"version": member.DelegateCur,
},
})
}
r.Db("enforcer_db").TableDrop(tableMembers).Run(session)
var tables []string
tables = append(tables, tableMembers)
createTable(tables, debug)
// Insert the new item into the database
_, err = r.Table(tableMembers).Insert(result.Members).RunWrite(session)
if err != nil {
if debug {
log.Println("Error inserting data in rethindkdb", err)
}
return
}
}
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 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)
}
}
