rename more interfaces

cmd/observernode/main.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
-	"github.com/my-cloud/ruthenium/domain/clock/tick"
+	"github.com/my-cloud/ruthenium/domain/clock"
 	"github.com/my-cloud/ruthenium/domain/network/p2p"
 	"github.com/my-cloud/ruthenium/domain/network/p2p/gp2p"
 	"github.com/my-cloud/ruthenium/domain/network/p2p/net"
@@ -48,7 +48,7 @@ func main() {
 	if err != nil {
 		logger.Fatal(fmt.Errorf("unable to unmarshal settings: %w", err).Error())
 	}
-	watch := tick.NewWatch()
+	watch := clock.NewWatch()
 	http.Handle("/", index.NewHandler(*templatesPath, logger))
 	http.Handle("/transaction", transaction.NewHandler(host, logger))
 	http.Handle("/transactions", transactions.NewHandler(host, logger))

cmd/validatornode/main.go

@@ -3,11 +3,11 @@ package main
 import (
 	"flag"
 	"fmt"
+	"github.com/my-cloud/ruthenium/domain/clock"
 	"github.com/my-cloud/ruthenium/infrastructure/config"
 	"github.com/my-cloud/ruthenium/infrastructure/file"
 	"strconv"
 
-	"github.com/my-cloud/ruthenium/domain/clock/tick"
 	"github.com/my-cloud/ruthenium/domain/encryption"
 	"github.com/my-cloud/ruthenium/domain/network/p2p"
 	"github.com/my-cloud/ruthenium/domain/network/p2p/gp2p"
@@ -65,14 +65,14 @@ func createHost(settingsPath *string, infuraKey *string, seedsPath *string, ip *
 		logger.Fatal(fmt.Errorf("unable to parse settings: %w", err).Error())
 	}
 	registry := poh.NewRegistry(*infuraKey, logger)
-	watch := tick.NewWatch()
-	synchronizer := createSynchronizer(*seedsPath, *ip, *port, settings, watch, logger)
-	blockchain := verification.NewBlockchain(registry, settings, synchronizer, logger)
-	transactionsPool := validation.NewTransactionsPool(blockchain, settings, synchronizer, address, logger)
-	synchronizationEngine := tick.NewEngine(synchronizer.Synchronize, watch, settings.SynchronizationTimer(), 1, 0)
-	validationEngine := tick.NewEngine(transactionsPool.Validate, watch, settings.ValidationTimer(), 1, 0)
-	verificationEngine := tick.NewEngine(blockchain.Update, watch, settings.ValidationTimer(), settings.VerificationsCountPerValidation(), 1)
-	handler := gp2p.NewHandler(blockchain, settings.Bytes(), synchronizer, transactionsPool, watch, logger)
+	watch := clock.NewWatch()
+	neighborhood := createNeighborhood(*seedsPath, *ip, *port, settings, watch, logger)
+	blockchain := verification.NewBlockchain(registry, settings, neighborhood, logger)
+	transactionsPool := validation.NewTransactionsPool(blockchain, settings, neighborhood, address, logger)
+	synchronizationEngine := clock.NewEngine(neighborhood.Synchronize, watch, settings.SynchronizationTimer(), 1, 0)
+	validationEngine := clock.NewEngine(transactionsPool.Validate, watch, settings.ValidationTimer(), 1, 0)
+	verificationEngine := clock.NewEngine(blockchain.Update, watch, settings.ValidationTimer(), settings.VerificationsCountPerValidation(), 1)
+	handler := gp2p.NewHandler(blockchain, settings.Bytes(), neighborhood, transactionsPool, watch, logger)
 	serverFactory := gp2p.NewServerFactory(handler, settings)
 	server, err := serverFactory.CreateServer(*port)
 	if err != nil {
@@ -81,7 +81,7 @@ func createHost(settingsPath *string, infuraKey *string, seedsPath *string, ip *
 	return p2p.NewHost(server, synchronizationEngine, validationEngine, verificationEngine, logger)
 }
 
-func createSynchronizer(seedsPath string, hostIp string, port int, settings *config.Settings, watch *tick.Watch, logger *console.Logger) *p2p.Synchronizer {
+func createNeighborhood(seedsPath string, hostIp string, port int, settings *config.Settings, watch *clock.Watch, logger *console.Logger) *p2p.Neighborhood {
 	var seedsStringTargets []string
 	parser := file.NewJsonParser()
 	err := parser.Parse(seedsPath, &seedsStringTargets)
@@ -100,5 +100,5 @@ func createSynchronizer(seedsPath string, hostIp string, port int, settings *con
 		}
 	}
 	clientFactory := gp2p.NewClientFactory(ipFinder, settings.ValidationTimeout())
-	return p2p.NewSynchronizer(clientFactory, hostIp, strconv.Itoa(port), settings.MaxOutboundsCount(), scoresBySeedTarget, watch)
+	return p2p.NewNeighborhood(clientFactory, hostIp, strconv.Itoa(port), settings.MaxOutboundsCount(), scoresBySeedTarget, watch)
 }

domain/clock/engine.go

@@ -1,7 +1,83 @@
 package clock
 
-type Engine interface {
-	Start()
-	Stop()
-	Do()
+import (
+	"github.com/my-cloud/ruthenium/domain"
+	"time"
+)
+
+type Engine struct {
+	function func(timestamp int64)
+
+	watch              domain.TimeProvider
+	timer              time.Duration
+	subTimer           time.Duration
+	ticker             *time.Ticker
+	occurrences        int64
+	skippedOccurrences int
+	started            bool
+	requested          bool
+}
+
+func NewEngine(function func(timestamp int64), watch domain.TimeProvider, timer time.Duration, occurrences int64, skippedOccurrences int) *Engine {
+	var subTimer time.Duration
+	if occurrences > 0 {
+		subTimer = time.Duration(timer.Nanoseconds() / occurrences)
+	} else {
+		subTimer = timer
+	}
+	ticker := time.NewTicker(timer)
+	return &Engine{function, watch, timer, subTimer, ticker, occurrences, skippedOccurrences, false, false}
+}
+
+func (engine *Engine) Pulse() {
+	if engine.started || engine.requested {
+		return
+	}
+	now := engine.watch.Now()
+	startTime := now.Truncate(engine.timer).Add(engine.timer)
+	deadline := startTime.Sub(now)
+	engine.ticker.Reset(deadline)
+	engine.requested = true
+	<-engine.ticker.C
+	engine.function(startTime.UnixNano())
+	engine.requested = false
+	if engine.started {
+		newParsedStartDate := startTime.Add(engine.timer)
+		newDeadline := newParsedStartDate.Sub(startTime)
+		engine.ticker.Reset(newDeadline)
+	} else {
+		engine.ticker.Stop()
+	}
+}
+
+func (engine *Engine) Start() {
+	if engine.started {
+		return
+	}
+	engine.started = true
+	initialTime := engine.watch.Now()
+	startTime := initialTime.Truncate(engine.timer).Add(engine.timer)
+	deadline := startTime.Sub(initialTime)
+	engine.ticker.Reset(deadline)
+	<-engine.ticker.C
+	engine.ticker.Reset(engine.subTimer)
+	occurrences := int(engine.occurrences)
+	for {
+		for i := 0; i < occurrences; i++ {
+			if i >= engine.skippedOccurrences {
+				if !engine.started {
+					engine.ticker.Stop()
+					return
+				}
+				now := engine.watch.Now().Round(engine.subTimer)
+				engine.function(now.UnixNano())
+			}
+			<-engine.ticker.C
+		}
+	}
+}
+
+func (engine *Engine) Stop() {
+	engine.started = false
+	engine.ticker.Reset(time.Nanosecond)
 }

domain/clock/tick/engine_test.go → domain/clock/engine_test.go

@@ -1,8 +1,8 @@
-package tick
+package clock
 
 import (
 	"fmt"
-	"github.com/my-cloud/ruthenium/domain/clock"
+	"github.com/my-cloud/ruthenium/domain"
 	"testing"
 	"time"
 
@@ -11,21 +11,21 @@ import (
 
 func Test_Do_NoError_FunctionCalled(t *testing.T) {
 	// Arrange
-	watchMock := new(clock.WatchMock)
+	watchMock := new(domain.TimeProviderMock)
 	watchMock.NowFunc = func() time.Time { return time.Unix(0, 0) }
 	var calls int
 	engine := NewEngine(func(int64) { calls++ }, watchMock, 1, 0, 0)
 
 	// Act
-	engine.Do()
+	engine.Pulse()
 
 	// Assert
 	test.Assert(t, calls == 1, fmt.Sprintf("The function is called %d times whereas it should be called once.", calls))
 }
 
 func Test_Start_NotStarted_Started(t *testing.T) {
 	// Arrange
-	watchMock := new(clock.WatchMock)
+	watchMock := new(domain.TimeProviderMock)
 	watchMock.NowFunc = func() time.Time { return time.Unix(0, 0) }
 	var engine = &Engine{}
 	var calls int