go/oasis-test-runner: Add sentry node support

go/oasis-test-runner/oasis/args.go

@@ -2,8 +2,10 @@ package oasis
 
 import (
 	"encoding/hex"
+	"fmt"
 	"path/filepath"
 	"strconv"
+	"strings"
 
 	"github.com/oasislabs/oasis-core/go/client"
 	"github.com/oasislabs/oasis-core/go/common/crypto/signature"
@@ -273,6 +275,36 @@ func (args *argBuilder) sentryControlPort(port uint16) *argBuilder {
 	return args
 }
 
+func (args *argBuilder) addSentries(sentries []*Sentry) *argBuilder {
+	addrs := []string{}
+	certFiles := []string{}
+	for _, sentry := range sentries {
+		addrs = append(addrs, fmt.Sprintf("127.0.0.1:%d", sentry.controlPort))
+		certFiles = append(certFiles, sentry.TLSCertPath())
+	}
+	args = args.workerSentryAddresses(strings.Join(addrs, ","))
+	args = args.workerSentryCertFiles(strings.Join(certFiles, ","))
+	return args
+}
+
+func (args *argBuilder) addSentriesAsPersistentPeers(sentries []*Sentry) *argBuilder {
+	peers := []string{}
+	for _, sentry := range sentries {
+		peers = append(peers, fmt.Sprintf("%[email protected]:%d", sentry.consensusAddress, sentry.consensusPort))
+	}
+	args = args.tendermintPersistentPeers(strings.Join(peers, ","))
+	return args
+}
+
+func (args *argBuilder) addValidatorsAsPrivatePeers(validators []*Validator) *argBuilder {
+	peers := []string{}
+	for _, val := range validators {
+		peers = append(peers, fmt.Sprintf("%[email protected]:%d", val.consensusAddress, val.consensusPort))
+	}
+	args = args.tendermintPrivatePeers(strings.Join(peers, ","))
+	return args
+}
+
 func (args *argBuilder) appendSeedNodes(net *Network) *argBuilder {
 	if seed := net.seedNode; seed != nil {
 		args.vec = append(args.vec, []string{

go/oasis-test-runner/oasis/fixture.go

@@ -22,6 +22,7 @@ type NetworkFixture struct {
 	Keymanagers    []KeymanagerFixture    `json:"keymanagers,omitempty"`
 	StorageWorkers []StorageWorkerFixture `json:"storage_workers,omitempty"`
 	ComputeWorkers []ComputeWorkerFixture `json:"compute_workers,omitempty"`
+	Sentries       []SentryFixture        `json:"sentries,omitempty"`
 	Clients        []ClientFixture        `json:"clients,omitempty"`
 	ByzantineNodes []ByzantineFixture     `json:"byzantine_nodes,omitempty"`
 }
@@ -54,6 +55,13 @@ func (f *NetworkFixture) Create(env *env.Env) (*Network, error) {
 		}
 	}
 
+	// Provision the sentry nodes.
+	for _, fx := range f.Sentries {
+		if _, err = fx.Create(net); err != nil {
+			return nil, err
+		}
+	}
+
 	// Provision validators.
 	for _, fx := range f.Validators {
 		if _, err = fx.Create(net); err != nil {
@@ -108,6 +116,8 @@ type TEEFixture struct {
 // ValidatorFixture is a validator fixture.
 type ValidatorFixture struct {
 	Entity int `json:"entity"`
+
+	Sentries []int `json:"sentries,omitempty"`
 }
 
 // Create instantiates the validator described by the fixture.
@@ -118,7 +128,8 @@ func (f *ValidatorFixture) Create(net *Network) (*Validator, error) {
 	}
 
 	return net.NewValidator(&ValidatorCfg{
-		Entity: entity,
+		Entity:        entity,
+		SentryIndices: f.Sentries,
 	})
 }
 
@@ -239,6 +250,18 @@ func (f *ComputeWorkerFixture) Create(net *Network) (*Compute, error) {
 	})
 }
 
+// SentryFixture is a sentry node fixture.
+type SentryFixture struct {
+	Validators []int `json:"validators"`
+}
+
+// Create instantiates the client node described by the fixture.
+func (f *SentryFixture) Create(net *Network) (*Sentry, error) {
+	return net.NewSentry(&SentryCfg{
+		ValidatorIndices: f.Validators,
+	})
+}
+
 // ClientFixture is a client node fixture.
 type ClientFixture struct {
 }
@@ -277,6 +300,18 @@ func resolveEntity(net *Network, index int) (*Entity, error) {
 	return entities[index], nil
 }
 
+func resolveValidators(net *Network, indices []int) ([]*Validator, error) {
+	allValidators := net.Validators()
+	validators := []*Validator{}
+	for _, index := range indices {
+		if index < 0 || index >= len(allValidators) {
+			return nil, fmt.Errorf("invalid validator index: %d", index)
+		}
+		validators = append(validators, allValidators[index])
+	}
+	return validators, nil
+}
+
 func resolveRuntime(net *Network, index int) (*Runtime, error) {
 	runtimes := net.Runtimes()
 	if index < 0 || index >= len(runtimes) {
@@ -299,3 +334,15 @@ func resolveRuntimeOfKind(net *Network, index int, kind registry.RuntimeKind) (*
 	}
 	return runtime, nil
 }
+
+func resolveSentries(net *Network, indices []int) ([]*Sentry, error) {
+	allSentries := net.Sentries()
+	sentries := []*Sentry{}
+	for _, index := range indices {
+		if index < 0 || index >= len(allSentries) {
+			return nil, fmt.Errorf("invalid sentry index: %d", index)
+		}
+		sentries = append(sentries, allSentries[index])
+	}
+	return sentries, nil
+}

go/oasis-test-runner/oasis/oasis.go

@@ -60,6 +60,7 @@ type Network struct {
 	keymanager     *Keymanager
 	storageWorkers []*Storage
 	computeWorkers []*Compute
+	sentries       []*Sentry
 	clients        []*Client
 	byzantine      []*Byzantine
 
@@ -147,6 +148,11 @@ func (net *Network) ComputeWorkers() []*Compute {
 	return net.computeWorkers
 }
 
+// Sentries returns the sentry nodes associated with the network.
+func (net *Network) Sentries() []*Sentry {
+	return net.sentries
+}
+
 // Clients returns the client nodes associated with the network.
 func (net *Network) Clients() []*Client {
 	return net.clients
@@ -300,10 +306,20 @@ func (net *Network) Start() error {
 		}
 	}
 
+	net.logger.Debug("starting sentry node(s)")
+	for _, v := range net.sentries {
+		if err := v.startNode(); err != nil {
+			net.logger.Error("failed to start sentry node",
+				"err", err,
+			)
+			return err
+		}
+	}
+
 	net.logger.Debug("starting client node(s)")
 	for _, v := range net.clients {
 		if err := v.startNode(); err != nil {
-			net.logger.Error("failed to start client worker",
+			net.logger.Error("failed to start client node",
 				"err", err,
 			)
 			return err

go/oasis-test-runner/oasis/sentry.go

@@ -0,0 +1,103 @@
+package oasis
+
+import (
+	"fmt"
+
+	"github.com/oasislabs/oasis-core/go/common/crypto/signature"
+	fileSigner "github.com/oasislabs/oasis-core/go/common/crypto/signature/signers/file"
+	"github.com/oasislabs/oasis-core/go/common/identity"
+	"github.com/oasislabs/oasis-core/go/oasis-test-runner/env"
+	"github.com/oasislabs/oasis-core/go/tendermint/crypto"
+)
+
+// Sentry is an Oasis sentry node.
+type Sentry struct {
+	net *Network
+	dir *env.Dir
+
+	validatorIndices []int
+
+	consensusPublicKey signature.PublicKey
+	consensusAddress   string
+	consensusPort      uint16
+	controlPort        uint16
+}
+
+// SentryCfg is the Oasis sentry node configuration.
+type SentryCfg struct {
+	ValidatorIndices []int
+}
+
+// LogPath returns the path to the node's log.
+func (sentry *Sentry) LogPath() string {
+	return nodeLogPath(sentry.dir)
+}
+
+// TLSCertPath returns the path to the node's TLS certificate.
+func (sentry *Sentry) TLSCertPath() string {
+	return nodeTLSCertPath(sentry.dir)
+}
+
+func (sentry *Sentry) startNode() error {
+	validators, err := resolveValidators(sentry.net, sentry.validatorIndices)
+	if err != nil {
+		return err
+	}
+
+	args := newArgBuilder().
+		debugAllowTestKeys().
+		sentry().
+		tendermintCoreListenAddress(sentry.consensusPort).
+		sentryControlPort(sentry.controlPort).
+		appendNetwork(sentry.net).
+		addValidatorsAsPrivatePeers(validators)
+
+	if _, err := sentry.net.startOasisNode(sentry.dir, nil, args, "sentry", false, false); err != nil {
+		return fmt.Errorf("oasis/sentry: failed to launch node: %w", err)
+	}
+
+	return nil
+}
+
+// NewSentry provisions a new sentry node and adds it to the network.
+func (net *Network) NewSentry(cfg *SentryCfg) (*Sentry, error) {
+	sentryName := fmt.Sprintf("sentry-%d", len(net.sentries))
+
+	sentryDir, err := net.baseDir.NewSubDir(sentryName)
+	if err != nil {
+		net.logger.Error("failed to create sentry subdir",
+			"err", err,
+			"sentry_name", sentryName,
+		)
+		return nil, fmt.Errorf("oasis/sentry: failed to create sentry subdir: %w", err)
+	}
+
+	// Pre-provision the node identity, so that we can pass the sentry node's
+	// consensus public key and address to validator to configure the sentry
+	// node as a persistent peer.
+	signerFactory := fileSigner.NewFactory(sentryDir.String(), signature.SignerNode, signature.SignerP2P, signature.SignerConsensus)
+	sentryIdentity, err := identity.LoadOrGenerate(sentryDir.String(), signerFactory)
+	if err != nil {
+		net.logger.Error("failed to provision sentry identity",
+			"err", err,
+			"sentry_name", sentryName,
+		)
+		return nil, fmt.Errorf("oasis/sentry: failed to provision sentry identity: %w", err)
+	}
+	sentryConsensusPublicKey := sentryIdentity.ConsensusSigner.Public()
+
+	sentry := &Sentry{
+		net:                net,
+		dir:                sentryDir,
+		validatorIndices:   cfg.ValidatorIndices,
+		consensusPublicKey: sentryConsensusPublicKey,
+		consensusAddress:   crypto.PublicKeyToTendermint(&sentryConsensusPublicKey).Address().String(),
+		consensusPort:      net.nextNodePort,
+		controlPort:        net.nextNodePort + 1,
+	}
+
+	net.sentries = append(net.sentries, sentry)
+	net.nextNodePort += 2
+
+	return sentry, nil
+}