-
Notifications
You must be signed in to change notification settings - Fork 85
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This change rewires thing in a way that we consume less bandwidth. Instead of broadcasting the interface messages, we broadcast a blockchain that dynamically tracks records of the address and the nodes of the network. The blockchain is sealed and keys are automatically rotated via OTP. The messages are then sent over p2p network selectively for each stream by decoding the interface packet, and using the blockchain as resolver
- Loading branch information
Showing
13 changed files
with
468 additions
and
150 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,66 @@ | ||
| package blockchain | ||
|
|
||
| import ( | ||
| "crypto/sha256" | ||
| "encoding/hex" | ||
| "fmt" | ||
| "time" | ||
| ) | ||
|
|
||
| // Block represents each 'item' in the blockchain | ||
| type Block struct { | ||
| Index int | ||
| Timestamp string | ||
| AddressMap map[string]string | ||
| Hash string | ||
| PrevHash string | ||
| } | ||
|
|
||
| // Blockchain is a series of validated Blocks | ||
| type Blockchain []Block | ||
|
|
||
| func (b Blockchain) IsMoreRecent(bb Blockchain) bool { | ||
| return len(b) > len(bb) || len(b) == len(bb) && b[len(b)-1].Hash != bb[len(bb)-1].Hash | ||
| } | ||
|
|
||
| // make sure block is valid by checking index, and comparing the hash of the previous block | ||
| func (newBlock Block) IsValid(oldBlock Block) bool { | ||
| if oldBlock.Index+1 != newBlock.Index { | ||
| return false | ||
| } | ||
|
|
||
| if oldBlock.Hash != newBlock.PrevHash { | ||
| return false | ||
| } | ||
|
|
||
| if newBlock.Checksum() != newBlock.Hash { | ||
| return false | ||
| } | ||
|
|
||
| return true | ||
| } | ||
|
|
||
| // Checksum does SHA256 hashing of the block | ||
| func (b Block) Checksum() string { | ||
| record := fmt.Sprint(b.Index, b.Timestamp, b.AddressMap, b.PrevHash) | ||
| h := sha256.New() | ||
| h.Write([]byte(record)) | ||
| hashed := h.Sum(nil) | ||
| return hex.EncodeToString(hashed) | ||
| } | ||
|
|
||
| // create a new block using previous block's hash | ||
| func (oldBlock Block) NewBlock(s map[string]string) Block { | ||
|
|
||
| var newBlock Block | ||
|
|
||
| t := time.Now() | ||
|
|
||
| newBlock.Index = oldBlock.Index + 1 | ||
| newBlock.Timestamp = t.String() | ||
| newBlock.AddressMap = s | ||
| newBlock.PrevHash = oldBlock.Hash | ||
| newBlock.Hash = newBlock.Checksum() | ||
|
|
||
| return newBlock | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,176 @@ | ||
| package blockchain | ||
|
|
||
| import ( | ||
| "context" | ||
| "encoding/json" | ||
| "io" | ||
| "log" | ||
| "sync" | ||
| "time" | ||
|
|
||
| "github.com/mudler/edgevpn/pkg/hub" | ||
| ) | ||
|
|
||
| type Ledger struct { | ||
| sync.Mutex | ||
| Blockchain Blockchain | ||
|
|
||
| maxChainSize int | ||
| channel io.Writer | ||
| } | ||
|
|
||
| // New returns a new ledger which writes to the writer | ||
| func New(w io.Writer, maxChainSize int) *Ledger { | ||
| c := &Ledger{channel: w, maxChainSize: maxChainSize} | ||
| c.newGenesis() | ||
| return c | ||
| } | ||
|
|
||
| func (l *Ledger) newGenesis() { | ||
| t := time.Now() | ||
| genesisBlock := Block{} | ||
| genesisBlock = Block{0, t.String(), map[string]string{}, genesisBlock.Checksum(), ""} | ||
| l.Blockchain = append(l.Blockchain, genesisBlock) | ||
| } | ||
|
|
||
| // Syncronizer starts a goroutine which | ||
| // writes the blockchain to the periodically | ||
| func (l *Ledger) Syncronizer(ctx context.Context, t time.Duration) { | ||
| go func() { | ||
| t := time.NewTicker(t) | ||
| defer t.Stop() | ||
| for { | ||
| select { | ||
| case <-t.C: | ||
| l.Lock() | ||
| bytes, err := json.Marshal(l.Blockchain) | ||
| if err != nil { | ||
| log.Println(err) | ||
| } | ||
| l.channel.Write(bytes) | ||
|
|
||
| // Reset blockchain if we exceed chainsize | ||
| if l.maxChainSize != 0 && len(l.Blockchain) > l.maxChainSize { | ||
| l.Blockchain = []Block{} | ||
| } | ||
| l.Unlock() | ||
| case <-ctx.Done(): | ||
| return | ||
| } | ||
| } | ||
| }() | ||
| } | ||
|
|
||
| // String returns the blockchain as string | ||
| func (l *Ledger) String() string { | ||
| bytes, _ := json.MarshalIndent(l.Blockchain, "", " ") | ||
| return string(bytes) | ||
| } | ||
|
|
||
| // Update the blockchain from a message | ||
| func (l *Ledger) Update(h *hub.Message) (err error) { | ||
| chain := make(Blockchain, 0) | ||
|
|
||
| err = json.Unmarshal([]byte(h.Message), &chain) | ||
| if err != nil { | ||
| return | ||
| } | ||
|
|
||
| l.Lock() | ||
| if chain.IsMoreRecent(l.Blockchain) { | ||
| l.Blockchain = chain | ||
| } | ||
| l.Unlock() | ||
|
|
||
| return | ||
| } | ||
|
|
||
| // Persist an async data to the blockchain. | ||
| // Sends a broadcast at the specified interval | ||
| // by making sure the async retrieved value is written to the | ||
| // blockchain | ||
| func (l *Ledger) Persist(ctx context.Context, t time.Duration, key string, async func() string) { | ||
| go func() { | ||
| t := time.NewTicker(t) | ||
| defer t.Stop() | ||
| for { | ||
| select { | ||
| case <-t.C: | ||
| value := async() | ||
| // Retrieve current ID for ip in the blockchain | ||
| existingValue, found := l.GetKey(key) | ||
| // If mismatch, update the blockchain | ||
| if !found || existingValue != value { | ||
| updatedMap := map[string]string{} | ||
| updatedMap[key] = value | ||
| l.Add(updatedMap) | ||
| } | ||
| case <-ctx.Done(): | ||
| return | ||
| } | ||
| } | ||
| }() | ||
| } | ||
|
|
||
| func (l *Ledger) lastBlock() Block { | ||
| return (l.Blockchain[len(l.Blockchain)-1]) | ||
| } | ||
|
|
||
| // GetKey retrieve the current key from the blockchain | ||
| func (l *Ledger) GetKey(s string) (value string, exists bool) { | ||
| l.Lock() | ||
| defer l.Unlock() | ||
| if len(l.Blockchain) > 0 { | ||
| last := l.lastBlock() | ||
| value, exists = last.AddressMap[s] | ||
| if exists { | ||
| return | ||
| } | ||
| } | ||
|
|
||
| return | ||
| } | ||
|
|
||
| // ExistsValue returns true if there is one element with a matching value | ||
| func (l *Ledger) ExistsValue(v string) (exists bool) { | ||
| l.Lock() | ||
| defer l.Unlock() | ||
| if len(l.Blockchain) > 0 { | ||
| for _, bv := range l.lastBlock().AddressMap { | ||
| if bv == v { | ||
| exists = true | ||
| return | ||
| } | ||
| } | ||
| } | ||
|
|
||
| return | ||
| } | ||
|
|
||
| // Add data to the blockchain | ||
| func (l *Ledger) Add(s map[string]string) { | ||
| l.Lock() | ||
| current := l.lastBlock().AddressMap | ||
| for s, k := range s { | ||
| current[s] = k | ||
| } | ||
| l.Unlock() | ||
| l.writeData(current) | ||
| } | ||
|
|
||
| func (l *Ledger) writeData(s map[string]string) { | ||
| newBlock := l.lastBlock().NewBlock(s) | ||
|
|
||
| if newBlock.IsValid(l.lastBlock()) { | ||
| l.Lock() | ||
| l.Blockchain = append(l.Blockchain, newBlock) | ||
| l.Unlock() | ||
| } | ||
|
|
||
| bytes, err := json.Marshal(l.Blockchain) | ||
| if err != nil { | ||
| log.Println(err) | ||
| } | ||
|
|
||
| l.channel.Write(bytes) | ||
| } |
Oops, something went wrong.