/******************************************************************************************
Main() method , starts the proceedings by sending the Server in Follower phase
******************************************************************************************/
func main() {
myServerId, _ := strconv.Atoi(os.Args[1])
serverStateFile := os.Args[2]
configFile := os.Args[3]
minTimeOut, _ := strconv.Atoi(os.Args[4])
maxTimeOut, _ := strconv.Atoi(os.Args[5])
fmt.Println("Starting Main", myServerId)
machine := NewMachine(myServerId, serverStateFile, configFile, minTimeOut, maxTimeOut)
//***********For Tester Purpose Only***********
testerPort := os.Args[6]
var t Testerstruct
t.TesterInit(&machine, testerPort)
go t.TesterRecv(&machine)
//*********Tester Methods Closed***************
go cluster.ReceiveMessage(&machine.server)
go cluster.SendMessage(&machine.server)
fmt.Println("\nElection TimeOut", machine.Election_Timeout())
Start(&machine)
}
func main() {
gob.Register(cluster.AppendEntriesRequestStruct{})
gob.Register(cluster.AppendEntriesResponseStruct{})
gob.Register(cluster.RequestVoteRequestStruct{})
gob.Register(cluster.RequestVoteResponseStruct{})
myServerId, _ := strconv.Atoi(os.Args[1])
//serverStateFile := os.Args[2]
//configFile := os.Args[3]
//minTimeOut, _ := strconv.Atoi(os.Args[4])
//maxTimeOut, _ := strconv.Atoi(os.Args[5])
serverStateFile := "./serverState.json"
configFile := "./config.json"
minTimeOut := 5000
maxTimeOut := 6000
fmt.Println("Starting Main", myServerId)
machine := NewMachine(myServerId, serverStateFile, configFile, minTimeOut, maxTimeOut)
machine.Log = make([]cluster.LogEntry, 0)
machine.LastLogIndex = -1
machine.CommitIndex = -1
machine.LastApplied = -1
machine.NextIndex = make(map[int]int64)
machine.MatchIndex = make(map[int]int64)
machine.FollowerTerm = make(map[int]int)
for _, Sid := range machine.server.Peers() {
machine.NextIndex[Sid] = int64(0)
machine.MatchIndex[Sid] = int64(-1)
machine.FollowerTerm[Sid] = 0
}
//***********For Tester Purpose Only***********
/*testerPort := os.Args[6]
var t Testerstruct
t.TesterInit(&machine, testerPort)
go t.TesterRecv(&machine)
*/
//*********Tester Methods Closed***************
go cluster.ReceiveMessage(&machine.server)
go cluster.SendMessage(&machine.server)
go machine.StartRaftInbox()
fmt.Println("\nElection TimeOut", machine.Election_Timeout())
Start(&machine)
}
func TestBroadcastMsgCount(t *testing.T) {
// Create 4 servers
serverArray := make([]cluster.Server, 4)
send_count := 0
received_count := 0
// all_send_sockets := make([][]sendSocket,4,3)
// Start the receiver first , so that we catch all the packets
for tempServerId := 0; tempServerId <= 3; tempServerId++ {
serverArray[tempServerId] = cluster.NewServer(tempServerId+1, "config.json")
// fmt.Println("Press Any Enter to Start ...")
// var line string
// fmt.Scanln(&line)
go cluster.SendMessage(serverArray[tempServerId])
go cluster.ReceiveMessage(serverArray[tempServerId])
go receive_always(serverArray[tempServerId], &received_count)
}
for tempServerId := 0; tempServerId <= 3; tempServerId++ {
// Put cluster.Envelope after implementing Pacakges
for i := 1; i <= 50; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, Msg: "hello there"}
send_count += 3
}
fmt.Println("Sent all messages for Server ", serverArray[tempServerId].Pid())
}
time.Sleep(2 * time.Second)
fmt.Printf("\n--------Going to Count---------")
fmt.Printf("\nTotal msg sent " + strconv.Itoa(send_count))
fmt.Printf("\nReceived msg " + strconv.Itoa(received_count))
if send_count != received_count {
t.Errorf("send_count - %v , received_count - %v", send_count, received_count)
}
}
/******************************************************************************************
Main() method , starts the proceedings by sending the Server in Follower phase
******************************************************************************************/
func main() {
gob.Register(cluster.AppendEntriesRequestStruct{})
gob.Register(cluster.AppendEntriesResponseStruct{})
gob.Register(cluster.RequestVoteRequestStruct{})
gob.Register(cluster.RequestVoteResponseStruct{})
myServerId, _ := strconv.Atoi(os.Args[1])
serverStateFile := os.Args[2]
configFile := os.Args[3]
minTimeOut, _ := strconv.Atoi(os.Args[4])
maxTimeOut, _ := strconv.Atoi(os.Args[5])
fmt.Println("Starting Main", myServerId)
machine := NewMachine(myServerId, serverStateFile, configFile, minTimeOut, maxTimeOut)
machine.Log = make([]cluster.LogEntry, 0)
machine.NextIndex = make(map[int]int64)
machine.MatchIndex = make(map[int]int64)
machine.FollowerTerm = make(map[int]int)
machine.Client_channel = make(chan string)
machine.LastLogIndex = -1
machine.CommitIndex = -1
machine.LastApplied = -1
machine.LogKVStore, machine.DataKVStore = machine.loadDataFromLevelDB()
if machine.LogKVStore == nil || machine.DataKVStore == nil {
fmt.Println("Error in LevelDB files")
return
}
for _, Sid := range machine.server.Peers() {
machine.NextIndex[Sid] = int64(0)
machine.MatchIndex[Sid] = int64(-1)
machine.FollowerTerm[Sid] = 0
}
//***********For Tester Purpose Only***********
testerPort := os.Args[6]
var t Testerstruct
t.TesterInit(&machine, testerPort)
go t.TesterRecv(&machine)
//*********Tester Methods Closed***************
go cluster.ReceiveMessage(&machine.server)
go cluster.SendMessage(&machine.server)
//go machine.every5sec()
//go machine.StartRaftInbox()
fmt.Println("\nElection TimeOut", machine.Election_Timeout())
Start(&machine)
}
func TestUnicastMsgCount(t *testing.T) {
// Create 4 servers
serverArray := make([]cluster.Server, 4)
send_count := 0
received_count := 0
// Start the receiver first , so that we catch all the packets
for tempServerId := 0; tempServerId <= 3; tempServerId++ {
serverArray[tempServerId] = cluster.NewServer(tempServerId+1, "config.json")
go cluster.SendMessage(serverArray[tempServerId])
go cluster.ReceiveMessage(serverArray[tempServerId])
// *********** Error Prone Code ********************
// 1. Corrected code , which calls a function created below
// Uncomment following line to work smoothly without exception (and comment option 2)
// go receive_always(serverArray[tempServerId], &received_count)
// 2. Errorneous code , which create a go-routine here itself and somehow throws exception
// Comment following code to work smoothly and Uncomment option 1
go func() {
fmt.Println("Value of i :- ", tempServerId)
_ = <-serverArray[tempServerId].Inbox()
mutex1.Lock()
received_count += 1
mutex1.Unlock()
}()
// ********** Ends *********************************
}
for tempServerId := 0; tempServerId <= 3; tempServerId++ {
count := rand.Intn(100)
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 1, Msg: "hello there"}
send_count += 1
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 2, Msg: "hello there"}
send_count += 1
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 3, Msg: "hello there"}
send_count += 1
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 4, Msg: "hello there"}
send_count += 1
// Take few random values and send those many Envelopes
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, Msg: "hello there"}
send_count += 3
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 1, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 2, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 3, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: 4, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[tempServerId].Outbox() <- &cluster.Envelope{Pid: cluster.BROADCAST, Msg: "hello there"}
send_count += 3
}
fmt.Println("Sent all messages for Server ", serverArray[tempServerId].Pid())
}
time.Sleep(2 * time.Second)
fmt.Printf("\n--------Going to Count---------")
fmt.Printf("\nTotal msg sent " + strconv.Itoa(send_count))
fmt.Printf("\nReceived msg " + strconv.Itoa(received_count))
if send_count != received_count {
t.Errorf("send_count - %v , received_count - %v", send_count, received_count)
}
}
// Testing only for UNICAST messaging
func TestUnicastMsgCount(t *testing.T) {
send_count = 0
received_count = 0
fmt.Printf("\n\nTesting UNICAST ...\n")
// Create 4 servers
// Start the receiver first , so that we catch all the packets
for id := 0; id <= 3; id++ {
serverArray[id] = cluster.NewServer(id+1, "config.json")
go cluster.SendMessage(serverArray[id])
go cluster.ReceiveMessage(serverArray[id])
go receive_always(serverArray[id], &received_count)
}
for id := 0; id <= 3; id++ {
count := rand.Intn(100)
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 1, Msg: "hello there"}
send_count += 1
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 2, Msg: "hello there"}
send_count += 1
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 3, Msg: "hello there"}
send_count += 1
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 4, Msg: "hello there"}
send_count += 1
// Take few random values and send those many Envelopes
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 1, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 2, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 3, Msg: "hello there"}
send_count += 1
}
count = rand.Intn(1000)
for i := 1; i <= count; i++ {
serverArray[id].Outbox() <- &cluster.Envelope{Pid: 4, Msg: "hello there"}
send_count += 1
}
//fmt.Println("Sent all messages for Server ", serverArray[id].Pid())
}
time.Sleep(2 * time.Second)
fmt.Printf("\n--------Going to Count---------")
fmt.Printf("\nTotal msg sent " + strconv.Itoa(send_count))
fmt.Printf("\nReceived msg " + strconv.Itoa(received_count))
fmt.Printf("\nTesing UNICAST result")
if send_count != received_count {
t.Errorf("send_count - %v , received_count - %v", send_count, received_count)
}
fmt.Printf("\n\n\n")
}