core: Add Consensus to replace core.Blocklattice (#35)

* Make Sequencer return slice of blocks.

* Fix naming issue

The function 'getHeightVecto' would return ackingStatusVector.

* Fix comment error.

* Add methods to collect info when proposing blocks.

* Add test.App

* Add test.Gov

* Move this type to core.types to avoid cyclic import.

* Add core.Consensus

* Move getMedianTime, interpoTime to util

These functions are not depending on members of core.consensusTimestamp and
is required when testing core.Consensus.

* Make sure types.Block.Clone would copy critical fields.

* Remove core.blocklattice

* Define 'infinity' in core/total-ordering

This definition is defined in core/blocklattice originally.

* Fix a bug when processing the same block twice.

* Integrate simulation with core.Consensus

core.Consensus is a replacement of core.Blocklattice

* Fix the comment to use sigular form.

* Move lock mechanism to sub modules.

* phi should be 2*fmax+1

* Fixup: should aborting when the validator is added

* Fix for new block fields

* Fix the bug that the total ordering sequence is wrong.

1 files changed, 50 insertions, 1 deletions

diff --git a/core/utils.go b/core/utils.go
index 2f87f97..d023d2e 100644
--- a/core/utils.go
+++ b/core/utils.go
@@ -18,11 +18,21 @@
 package core
 
 import (
+	"errors"
 	"fmt"
 	"os"
+	"sort"
+	"time"
+
+	"github.com/dexon-foundation/dexon-consensus-core/common"
+	"github.com/dexon-foundation/dexon-consensus-core/core/types"
 )
 
-var debug = false
+var (
+	debug = false
+	// ErrEmptyTimestamps would be reported if Block.timestamps is empty.
+	ErrEmptyTimestamps = errors.New("timestamp vector should not be empty")
+)
 
 func init() {
 	if os.Getenv("DEBUG") != "" {
@@ -43,3 +53,42 @@ func Debugln(args ...interface{}) {
 		fmt.Println(args)
 	}
 }
+
+func interpoTime(t1 time.Time, t2 time.Time, sep int) []time.Time {
+	if sep == 0 {
+		return []time.Time{}
+	}
+	if t1.After(t2) {
+		return interpoTime(t2, t1, sep)
+	}
+	timestamps := make([]time.Time, sep)
+	duration := t2.Sub(t1)
+	period := time.Duration(
+		(duration.Nanoseconds() / int64(sep+1))) * time.Nanosecond
+	prevTime := t1
+	for idx := range timestamps {
+		prevTime = prevTime.Add(period)
+		timestamps[idx] = prevTime
+	}
+	return timestamps
+}
+func getMedianTime(block *types.Block) (t time.Time, err error) {
+	timestamps := []time.Time{}
+	for _, timestamp := range block.Timestamps {
+		timestamps = append(timestamps, timestamp)
+	}
+	if len(timestamps) == 0 {
+		err = ErrEmptyTimestamps
+		return
+	}
+	sort.Sort(common.ByTime(timestamps))
+	if len(timestamps)%2 == 0 {
+		t1 := timestamps[len(timestamps)/2-1]
+		t2 := timestamps[len(timestamps)/2]
+		t = interpoTime(t1, t2, 1)[0]
+	} else {
+		t = timestamps[len(timestamps)/2]
+	}
+	return
+
+}