func NetworkProcessor(state interfaces.IState) {
netloop:
for {
// This loop looks at the input queues and the invalid queues and
// Handles messages as they come in. If nothing is read, it sleeps
// for 500 milliseconds. Note you only sleep if both queues test
// to be empty.
select {
case msg, ok := <-state.NetworkInMsgQueue():
if ok {
//log.Printf("NetworkIn: %s\n", spew.Sdump(msg))
if state.PrintType(msg.Type()) {
log.Printf("Ignored: NetworkIn: %s\n", msg.String())
}
state.InMsgQueue() <- msg
continue netloop
}
default:
}
select {
case msg, ok := <-state.NetworkOutMsgQueue():
if ok {
var _ = msg
//log.Printf("NetworkOut: %s\n", msg.String())
if state.PrintType(msg.Type()) {
log.Printf("Ignored: NetworkOut: %s\n", msg.String())
}
switch msg.(type) {
case *messages.EOM:
msgeom := msg.(*messages.EOM)
server := state.GetServer().(*btcd.Server)
server.BroadcastMessage(msgeom)
default:
}
continue netloop
}
default:
}
select {
case msg, ok := <-state.NetworkInvalidMsgQueue():
if ok {
var _ = msg
if state.PrintType(msg.Type()) {
log.Printf("%20s %s\n", "Invalid:", msg.String())
}
continue netloop
}
default:
}
time.Sleep(time.Duration(500) * time.Millisecond)
}
}
// Execute the leader functions of the given message
func (m *EOM) LeaderExecute(state interfaces.IState) error {
DBM := NewDirectoryBlockSignature()
DBM.DirectoryBlockKeyMR = state.GetPreviousDirectoryBlock().GetKeyMR()
DBM.Sign(state)
state.NetworkOutMsgQueue() <- DBM
state.InMsgQueue() <- DBM
return nil
}
func Timer(state interfaces.IState) {
time.Sleep(2 * time.Second)
billion := int64(1000000000)
period := int64(state.GetDirectoryBlockInSeconds()) * billion
tenthPeriod := period / 10
now := time.Now().UnixNano() // Time in billionths of a second
wait := tenthPeriod - (now % tenthPeriod)
next := now + wait + tenthPeriod
if state.GetOut() {
state.Print(fmt.Sprintf("Time: %v\r\n", time.Now()))
}
time.Sleep(time.Duration(wait))
for {
for i := 0; i < 10; i++ {
// Don't stuff messages into the system if the
// Leader is behind.
for j := 0; j < 10 && len(state.AckQueue()) > 1000; j++ {
time.Sleep(time.Millisecond * 10)
}
now = time.Now().UnixNano()
if now > next {
wait = 1
for next < now {
next += tenthPeriod
}
wait = next - now
} else {
wait = next - now
next += tenthPeriod
}
time.Sleep(time.Duration(wait))
for len(state.InMsgQueue()) > 5000 {
time.Sleep(100 * time.Millisecond)
}
// Delay some number of milliseconds.
time.Sleep(time.Duration(state.GetTimeOffset().GetTimeMilli()) * time.Millisecond)
state.TickerQueue() <- i
}
}
}
func LoadJournalFromReader(s interfaces.IState, r *bufio.Reader) {
s.SetIsReplaying()
defer s.SetIsDoneReplaying()
fmt.Println("Replaying Journal")
time.Sleep(time.Second * 5)
fmt.Println("GO!")
t := 0
p := 0
for {
t++
fmt.Println("total: ", t, " processed: ", p, " \r")
// line is empty if no more data
line, err := r.ReadBytes('\n')
if len(line) == 0 || err != nil {
break
}
// Get the next word. If not MsgHex:, then go to next line.
adv, word, err := bufio.ScanWords(line, true)
if string(word) != "MsgHex:" {
continue // Go to next line.
}
line = line[adv:] // Remove "MsgHex:" from the line.
// Remove spaces.
adv, data, err := bufio.ScanWords(line, true)
if err != nil {
fmt.Println(err)
return
}
// Decode the hex
binary, err := hex.DecodeString(string(data))
if err != nil {
fmt.Println(err)
return
}
// Unmarshal the message.
msg, err := messages.UnmarshalMessage(binary)
if err != nil {
fmt.Println(err)
return
}
// Process the message.
s.InMsgQueue() <- msg
p++
if len(s.InMsgQueue()) > 200 {
for len(s.InMsgQueue()) > 50 {
time.Sleep(time.Millisecond * 10)
}
time.Sleep(time.Millisecond * 100)
}
}
//Waiting for state to process the message queue
//before we disable "IsDoneReplaying"
for len(s.InMsgQueue()) > 0 {
time.Sleep(time.Millisecond * 100)
}
}