func HandleV2RevealEntry(state interfaces.IState, params interface{}) (interface{}, *primitives.JSONError) {
e := new(EntryRequest)
err := MapToObject(params, e)
if err != nil {
return nil, NewInvalidParamsError()
}
entry := entryBlock.NewEntry()
if p, err := hex.DecodeString(e.Entry); err != nil {
return nil, NewInvalidEntryError()
} else {
_, err := entry.UnmarshalBinaryData(p)
if err != nil {
return nil, NewInvalidEntryError()
}
}
msg := new(messages.RevealEntryMsg)
msg.Entry = entry
msg.Timestamp = state.GetTimestamp()
state.APIQueue() <- msg
resp := new(RevealEntryResponse)
resp.Message = "Entry Reveal Success"
resp.EntryHash = entry.GetHash().String()
return resp, nil
}
func (m *MsgLog) PrtMsgs(state interfaces.IState) {
m.sem.Lock()
defer m.sem.Unlock()
if len(m.MsgList) == 0 {
return
}
fmt.Println(state.String())
fmt.Println("\n-----------------------------------------------------")
for _, e := range m.MsgList {
if e.valid {
dirstr := "->"
if !e.out {
dirstr = "<-"
}
fmt.Print(fmt.Sprintf("**** %8s %2s %8s %10s %5v **** %s\n", e.name, dirstr, e.peer, e.where, e.valid, e.msg.String()))
}
}
now := state.GetTimestamp()
m.last = now
m.msgCnt += len(m.MsgList) // Keep my counts
m.msgCntp += len(m.MsgList)
m.MsgList = m.MsgList[0:0] // Once printed, clear the list
fmt.Println(fmt.Sprintf("*** %42s **** ", fmt.Sprintf("Length: %d Msgs/sec: T %d P %d", len(m.MsgList), m.msgPerSec, m.msgPerSecp)))
fmt.Println("\n-----------------------------------------------------")
}
// Create a new Acknowledgement. This Acknowledgement
func NewAck(state interfaces.IState, hash interfaces.IHash) (iack interfaces.IMsg, err error) {
var last *Ack
if state.GetLastAck() != nil {
last = state.GetLastAck().(*Ack)
}
ack := new(Ack)
ack.Timestamp = state.GetTimestamp()
ack.MessageHash = hash
if last == nil {
ack.Height = 0
ack.SerialHash = ack.MessageHash
} else {
ack.Height = last.Height + 1
ack.SerialHash, err = primitives.CreateHash(last.MessageHash, ack.MessageHash)
if err != nil {
return nil, err
}
}
state.SetLastAck(ack)
// TODO: Add the signature.
return ack, nil
}
func NewEntryBlockResponse(state interfaces.IState) interfaces.IMsg {
msg := new(EntryBlockResponse)
msg.Peer2Peer = true // Always a peer2peer request.
msg.Timestamp = state.GetTimestamp()
return msg
}
func NewAddServerByHashMsg(state interfaces.IState, serverType int, newServerHash interfaces.IHash) interfaces.IMsg {
msg := new(AddServerMsg)
msg.ServerChainID = newServerHash
msg.ServerType = serverType
msg.Timestamp = state.GetTimestamp()
return msg
}
func NewAddServerMsg(state interfaces.IState, serverType int) interfaces.IMsg {
msg := new(AddServerMsg)
msg.ServerChainID = state.GetIdentityChainID()
msg.ServerType = serverType
msg.Timestamp = state.GetTimestamp()
return msg
}
func NewRemoveServerMsg(state interfaces.IState, chainId interfaces.IHash, serverType int) interfaces.IMsg {
msg := new(RemoveServerMsg)
msg.ServerChainID = chainId
msg.ServerType = serverType
msg.Timestamp = state.GetTimestamp()
return msg
}
func NewDBStateMissing(state interfaces.IState, dbheightStart uint32, dbheightEnd uint32) interfaces.IMsg {
msg := new(DBStateMissing)
msg.Peer2Peer = true // Always a peer2peer request.
msg.Timestamp = state.GetTimestamp()
msg.DBHeightStart = dbheightStart
msg.DBHeightEnd = dbheightEnd
return msg
}
// Try and Resend. Return true if we should keep the message, false if we should give up.
func (m *MessageBase) Expire(s interfaces.IState) (rtn bool) {
now := s.GetTimestamp().GetTimeMilli()
if m.expire == 0 {
m.expire = now
}
if now-m.expire > 5*60*1000 { // Keep messages for some length before giving up.
rtn = true
}
return
}
func NewMissingData(state interfaces.IState, requestHash interfaces.IHash) interfaces.IMsg {
msg := new(MissingData)
msg.Peer2Peer = true // Always a peer2peer request.
msg.Timestamp = state.GetTimestamp()
msg.RequestHash = requestHash
return msg
}
func NewMissingMsgResponse(state interfaces.IState, msgResponse interfaces.IMsg, ackResponse interfaces.IMsg) interfaces.IMsg {
msg := new(MissingMsgResponse)
msg.Peer2Peer = true // Always a peer2peer request.
msg.Timestamp = state.GetTimestamp()
msg.MsgResponse = msgResponse
msg.AckResponse = ackResponse
return msg
}
// Try and Resend. Return true if we should keep the message, false if we should give up.
func (m *MessageBase) Resend(s interfaces.IState) (rtn bool) {
now := s.GetTimestamp().GetTimeMilli()
if m.resend == 0 {
m.resend = now
return false
}
if now-m.resend > 10000 && len(s.NetworkOutMsgQueue()) < 1000 { // Resend every second
m.resend = now
return true
}
return false
}
func NewChangeServerKeyMsg(state interfaces.IState, identityChain interfaces.IHash, adminChange byte, keyPriority byte, keyType byte, key interfaces.IHash) interfaces.IMsg {
msg := new(ChangeServerKeyMsg)
msg.IdentityChainID = identityChain
msg.AdminBlockChange = adminChange
msg.KeyType = keyType
msg.KeyPriority = keyPriority
msg.Key = key
msg.Timestamp = state.GetTimestamp()
return msg
}
// NewMissingMsg: Build a missing Message request, and add the first Height
func NewMissingMsg(state interfaces.IState, vm int, dbHeight uint32, processlistHeight uint32) *MissingMsg {
msg := new(MissingMsg)
msg.Asking = state.GetIdentityChainID()
msg.Peer2Peer = true // Always a peer2peer request // .
msg.VMIndex = vm
msg.Timestamp = state.GetTimestamp()
msg.DBHeight = dbHeight
msg.ProcessListHeight = append(msg.ProcessListHeight, processlistHeight)
msg.SystemHeight = uint32(state.GetSystemHeight(dbHeight))
return msg
}
func (m *FullServerFault) Priority(state interfaces.IState) (priority int64) {
now := state.GetTimestamp()
// After 20 seconds, a negotiation's priority is now zero.
if now.GetTimeSeconds()-m.Timestamp.GetTimeSeconds() < 20 {
return 0
}
// oldest timestamp is highest priority
priority = math.MaxInt64 - m.Timestamp.GetTime().UnixNano()
// Mask off lowest byte
priority = (priority | 0xFF) ^ 0xFF
// Add VMIndex
priority = priority + int64(m.VMIndex)
return
}
func NewDataResponse(state interfaces.IState, dataObject interfaces.BinaryMarshallable,
dataType int,
dataHash interfaces.IHash) interfaces.IMsg {
msg := new(DataResponse)
msg.Peer2Peer = true
msg.Timestamp = state.GetTimestamp()
msg.DataHash = dataHash
msg.DataType = dataType
msg.DataObject = dataObject
//fmt.Println("DATARESPONSE: ", msg.DataObject)
return msg
}