Skip to content
Snippets Groups Projects
Commit 2077d6a3 authored by Hans Moog's avatar Hans Moog
Browse files

Refactor: refactored heartbeat manager

parent 312c3978
No related branches found
No related tags found
No related merge requests found
package heartbeat
import (
"github.com/iotaledger/goshimmer/packages/errors"
)
var (
ErrSigningFailed = errors.Wrap(errors.New("failed to sign"), "failed to sign")
)
...@@ -3,6 +3,8 @@ package heartbeat ...@@ -3,6 +3,8 @@ package heartbeat
import ( import (
"sync" "sync"
"github.com/iotaledger/goshimmer/packages/identity"
"github.com/iotaledger/goshimmer/packages/stringify" "github.com/iotaledger/goshimmer/packages/stringify"
"github.com/iotaledger/goshimmer/packages/errors" "github.com/iotaledger/goshimmer/packages/errors"
...@@ -77,6 +79,20 @@ func (heartbeat *Heartbeat) GetSignature() []byte { ...@@ -77,6 +79,20 @@ func (heartbeat *Heartbeat) GetSignature() []byte {
return heartbeat.signature return heartbeat.signature
} }
func (heartbeat *Heartbeat) Sign(identity *identity.Identity) (err errors.IdentifiableError) {
if marshaledHeartbeat, marshalErr := heartbeat.MarshalBinary(); marshalErr == nil {
if signature, signingErr := identity.Sign(marshaledHeartbeat); signingErr == nil {
heartbeat.SetSignature(signature)
} else {
err = ErrSigningFailed.Derive(signingErr, "failed to sign heartbeat")
}
} else {
err = marshalErr
}
return
}
func (heartbeat *Heartbeat) SetSignature(signature []byte) { func (heartbeat *Heartbeat) SetSignature(signature []byte) {
heartbeat.signatureMutex.Lock() heartbeat.signatureMutex.Lock()
defer heartbeat.signatureMutex.Unlock() defer heartbeat.signatureMutex.Unlock()
......
...@@ -3,6 +3,8 @@ package heartbeat ...@@ -3,6 +3,8 @@ package heartbeat
import ( import (
"sync" "sync"
"github.com/iotaledger/goshimmer/packages/identity"
"golang.org/x/crypto/blake2b" "golang.org/x/crypto/blake2b"
"github.com/iotaledger/goshimmer/packages/stringify" "github.com/iotaledger/goshimmer/packages/stringify"
...@@ -104,6 +106,20 @@ func (opinionStatement *OpinionStatement) SetSignature(signature []byte) { ...@@ -104,6 +106,20 @@ func (opinionStatement *OpinionStatement) SetSignature(signature []byte) {
opinionStatement.signature = signature opinionStatement.signature = signature
} }
func (opinionStatement *OpinionStatement) Sign(identity *identity.Identity) (err errors.IdentifiableError) {
if marshaledStatement, marshalErr := opinionStatement.MarshalBinary(); marshalErr == nil {
if signature, signingErr := identity.Sign(marshaledStatement); signingErr == nil {
opinionStatement.SetSignature(signature)
} else {
err = ErrSigningFailed.Derive(signingErr, "failed to sign opinion statement")
}
} else {
err = marshalErr
}
return
}
func (opinionStatement *OpinionStatement) GetHash() []byte { func (opinionStatement *OpinionStatement) GetHash() []byte {
opinionStatement.hashMutex.RLock() opinionStatement.hashMutex.RLock()
defer opinionStatement.hashMutex.RUnlock() defer opinionStatement.hashMutex.RUnlock()
......
...@@ -40,86 +40,65 @@ func (heartbeatManager *HeartbeatManager) InitialLike(transactionId []byte) { ...@@ -40,86 +40,65 @@ func (heartbeatManager *HeartbeatManager) InitialLike(transactionId []byte) {
heartbeatManager.initialOpinions[string(transactionId)] = true heartbeatManager.initialOpinions[string(transactionId)] = true
} }
func (heartbeatManager *HeartbeatManager) GenerateMainStatement() (result *heartbeat.OpinionStatement, err errors.IdentifiableError) { func (heartbeatManager *HeartbeatManager) GenerateHeartbeat() (result *heartbeat.Heartbeat, err errors.IdentifiableError) {
toggledTransactions := make([]*heartbeat.ToggledTransaction, 0) if mainStatement, mainStatementErr := heartbeatManager.GenerateMainStatement(); mainStatementErr == nil {
for transactionId, liked := range heartbeatManager.initialOpinions { generatedHeartbeat := heartbeat.NewHeartbeat()
if !liked { generatedHeartbeat.SetNodeId(heartbeatManager.identity.StringIdentifier)
newToggledTransaction := heartbeat.NewToggledTransaction() generatedHeartbeat.SetMainStatement(mainStatement)
newToggledTransaction.SetInitialStatement(true) generatedHeartbeat.SetNeighborStatements(nil)
newToggledTransaction.SetFinalStatement(false)
newToggledTransaction.SetTransactionId([]byte(transactionId)) if signingErr := generatedHeartbeat.Sign(heartbeatManager.identity); signingErr == nil {
result = generatedHeartbeat
toggledTransactions = append(toggledTransactions, newToggledTransaction) } else {
err = signingErr
} }
} else {
err = mainStatementErr
} }
return
}
func (heartbeatManager *HeartbeatManager) GenerateMainStatement() (result *heartbeat.OpinionStatement, err errors.IdentifiableError) {
mainStatement := heartbeat.NewOpinionStatement() mainStatement := heartbeat.NewOpinionStatement()
mainStatement.SetNodeId(heartbeatManager.identity.StringIdentifier) mainStatement.SetNodeId(heartbeatManager.identity.StringIdentifier)
mainStatement.SetTime(uint64(time.Now().Unix())) mainStatement.SetTime(uint64(time.Now().Unix()))
mainStatement.SetToggledTransactions(toggledTransactions) mainStatement.SetToggledTransactions(heartbeatManager.GenerateToggledTransactions())
if lastAppliedStatement := heartbeatManager.statementChain.lastAppliedStatement; lastAppliedStatement != nil { if lastAppliedStatement := heartbeatManager.statementChain.lastAppliedStatement; lastAppliedStatement != nil {
mainStatement.SetPreviousStatementHash(lastAppliedStatement.GetHash()) mainStatement.SetPreviousStatementHash(lastAppliedStatement.GetHash())
} }
marshaledStatement, marshalErr := mainStatement.MarshalBinary() if signingErr := mainStatement.Sign(heartbeatManager.identity); signingErr == nil {
if marshalErr != nil { result = mainStatement
err = marshalErr
return
}
signature, signingErr := heartbeatManager.identity.Sign(marshaledStatement)
if signingErr != nil {
err = ErrMalformedHeartbeat.Derive(signingErr.Error())
return heartbeatManager.ResetInitialOpinions()
heartbeatManager.statementChain.lastAppliedStatement = mainStatement
} else {
err = signingErr
} }
mainStatement.SetSignature(signature)
result = mainStatement
heartbeatManager.ResetInitialStatements()
heartbeatManager.statementChain.lastAppliedStatement = mainStatement
return return
} }
func (heartbeatManager *HeartbeatManager) ResetInitialStatements() { func (heartbeatManager *HeartbeatManager) GenerateToggledTransactions() []*heartbeat.ToggledTransaction {
heartbeatManager.initialOpinions = make(map[string]bool) toggledTransactions := make([]*heartbeat.ToggledTransaction, 0)
} for transactionId, liked := range heartbeatManager.initialOpinions {
if !liked {
func (heartbeatManager *HeartbeatManager) GenerateHeartbeat() (result *heartbeat.Heartbeat, err errors.IdentifiableError) { newToggledTransaction := heartbeat.NewToggledTransaction()
mainStatement, mainStatementErr := heartbeatManager.GenerateMainStatement() newToggledTransaction.SetInitialStatement(true)
if mainStatementErr != nil { newToggledTransaction.SetFinalStatement(false)
err = mainStatementErr newToggledTransaction.SetTransactionId([]byte(transactionId))
return
}
generatedHeartbeat := heartbeat.NewHeartbeat()
generatedHeartbeat.SetNodeId(heartbeatManager.identity.StringIdentifier)
generatedHeartbeat.SetMainStatement(mainStatement)
generatedHeartbeat.SetNeighborStatements(nil)
marshaledHeartbeat, marshalErr := generatedHeartbeat.MarshalBinary()
if marshalErr != nil {
err = marshalErr
return
}
signature, signingErr := heartbeatManager.identity.Sign(marshaledHeartbeat)
if signingErr != nil {
err = ErrMalformedHeartbeat.Derive(signingErr.Error())
return toggledTransactions = append(toggledTransactions, newToggledTransaction)
}
} }
generatedHeartbeat.SetSignature(signature)
result = generatedHeartbeat return toggledTransactions
}
return func (heartbeatManager *HeartbeatManager) ResetInitialOpinions() {
heartbeatManager.initialOpinions = make(map[string]bool)
} }
func (heartbeatManager *HeartbeatManager) ApplyHeartbeat(heartbeat *heartbeat.Heartbeat) (err errors.IdentifiableError) { func (heartbeatManager *HeartbeatManager) ApplyHeartbeat(heartbeat *heartbeat.Heartbeat) (err errors.IdentifiableError) {
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment