[Feature] Identity carry over part 6 / Configure Identity from constuctor

CHANGES.md

@@ -1,6 +1,24 @@
 ringpop-go changes
 ==================
 
+NEXT
+------
+
+### Release notes
+
+#### Change to identity-option
+
+Prior to ringpop NEXT the address was used as the identity of a member. Starting with version NEXT, it's possible to
+configure a separate identity. As a result, the behaviour of the `Identity` and `IdentityResolverFunc` has been changed.
+The `Identity` option now configures the identity of a member and will return an error when it matches an ip:port; services 
+that were using `Identity` or `IdentityResolverFunc` should now use the `Address` and `AddressResolverFunc` options.
+You could use the following `gofmt` snippets to easily refactor:
+
+```
+gofmt -r 'ringpop.Identity(a) -> ringpop.Address(a)' -w .
+gofmt -r 'ringpop.IdentityResolverFunc(a) -> ringpop.AddressResolverFunc(a)' -w .
+```
+
 v0.7.0
 ------
 

Makefile

@@ -1,4 +1,4 @@
-.PHONY: clean clean-mocks coveralls testpop lint mocks out setup test test-integration test-unit test-race
+.PHONY: clean clean-common clean-mocks coveralls testpop lint mocks out setup test test-integration test-unit test-race
 
 SHELL = /bin/bash
 
@@ -24,6 +24,9 @@ out:	test
 clean:
 	rm -f testpop
 
+clean-common:
+	rm -rf test/ringpop-common
+
 clean-mocks:
 	rm -f test/mocks/*.go forward/mock_*.go
 	rm -rf test/thrift/pingpong/

errors.go

@@ -7,12 +7,15 @@ var (
 	// be bootstrapped before they can operate correctly.
 	ErrNotBootstrapped = errors.New("ringpop is not bootstrapped")
 
-	// ErrEphemeralIdentity is returned by the identity resolver if TChannel is
+	// ErrEphemeralAddress is returned by the address resolver if TChannel is
 	// using port 0 and is not listening (and thus has not been assigned a port by
 	// the OS).
-	ErrEphemeralIdentity = errors.New("unable to resolve this node's identity from channel that is not yet listening")
+	ErrEphemeralAddress = errors.New("unable to resolve this node's address from channel that is not yet listening")
 
 	// ErrChannelNotListening is returned on bootstrap if TChannel is not
 	// listening.
 	ErrChannelNotListening = errors.New("tchannel is not listening")
+
+	// ErrInvalidIdentity is returned when the identity value is invalid.
+	ErrInvalidIdentity = errors.New("a hostport is not valid as an identity")
 )

examples/ping-json/main.go

@@ -84,11 +84,11 @@ func (w *worker) PingHandler(ctx json.Context, request *Ping) (*Pong, error) {
 	forwardOptions := &forward.Options{Headers: []byte(marshaledHeaders)}
 	handle, err := w.ringpop.HandleOrForward(request.Key, request.Bytes(), &res, "pingchannel", "/ping", tchannel.JSON, forwardOptions)
 	if handle {
-		identity, err := w.ringpop.WhoAmI()
+		address, err := w.ringpop.WhoAmI()
 		if err != nil {
 			return nil, err
 		}
-		return &Pong{"Hello, world!", identity, headers["p"]}, nil
+		return &Pong{"Hello, world!", address, headers["p"]}, nil
 	}
 
 	if err := json2.Unmarshal(res, &pong); err != nil {
@@ -111,7 +111,7 @@ func main() {
 
 	rp, err := ringpop.New("ping-app",
 		ringpop.Channel(ch),
-		ringpop.Identity(*hostport),
+		ringpop.Address(*hostport),
 		ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
 	)
 	if err != nil {

examples/ping-thrift-gen/main.go

@@ -86,15 +86,15 @@ func (w *worker) RegisterPing() error {
 }
 
 func (w *worker) Ping(ctx thrift.Context, request *gen.Ping) (*gen.Pong, error) {
-	identity, err := w.ringpop.WhoAmI()
+	address, err := w.ringpop.WhoAmI()
 	if err != nil {
 		return nil, err
 	}
 	headers := ctx.Headers()
 	pHeader := headers["p"]
 	return &gen.Pong{
 		Message: "Hello, world!",
-		From_:   identity,
+		From_:   address,
 		Pheader: &pHeader,
 	}, nil
 }
@@ -111,7 +111,7 @@ func main() {
 
 	rp, err := ringpop.New("ping-app",
 		ringpop.Channel(ch),
-		ringpop.Identity(*hostport),
+		ringpop.Address(*hostport),
 		ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
 	)
 	if err != nil {

examples/ping-thrift/main.go

@@ -74,14 +74,14 @@ func (w *worker) Ping(ctx thrift.Context, request *gen.Ping) (*gen.Pong, error)
 	forwardOptions := &forward.Options{Headers: marshaledHeaders.Bytes()}
 	handle, err := w.ringpop.HandleOrForward(request.Key, req, &res, "pingchannel", "PingPongService::Ping", tchannel.Thrift, forwardOptions)
 	if handle {
-		identity, err := w.ringpop.WhoAmI()
+		address, err := w.ringpop.WhoAmI()
 		if err != nil {
 			return nil, err
 		}
 		pHeader := headers["p"]
 		return &gen.Pong{
 			Message: "Hello, world!",
-			From_:   identity,
+			From_:   address,
 			Pheader: &pHeader,
 		}, nil
 	}
@@ -106,7 +106,7 @@ func main() {
 
 	rp, err := ringpop.New("ping-app",
 		ringpop.Channel(ch),
-		ringpop.Identity(*hostport),
+		ringpop.Address(*hostport),
 		ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
 	)
 	if err != nil {

examples/role-labels/main.go

@@ -82,7 +82,7 @@ func main() {
 
 	rp, err := ringpop.New("ping-app",
 		ringpop.Channel(ch),
-		ringpop.Identity(*hostport),
+		ringpop.Address(*hostport),
 		ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
 	)
 	if err != nil {

forward/forwarder.go

@@ -99,8 +99,8 @@ type Forwarder struct {
 func NewForwarder(s Sender, ch shared.SubChannel) *Forwarder {
 
 	logger := logging.Logger("forwarder")
-	if identity, err := s.WhoAmI(); err == nil {
-		logger = logger.WithField("local", identity)
+	if address, err := s.WhoAmI(); err == nil {
+		logger = logger.WithField("local", address)
 	}
 
 	return &Forwarder{

forward/request_sender.go

@@ -71,8 +71,8 @@ func newRequestSender(sender Sender, emitter events.EventEmitter, channel shared
 	destination, service, endpoint string, format tchannel.Format, opts *Options) *requestSender {
 
 	logger := logging.Logger("sender")
-	if identity, err := sender.WhoAmI(); err != nil {
-		logger = logger.WithField("local", identity)
+	if address, err := sender.WhoAmI(); err != nil {
+		logger = logger.WithField("local", address)
 	}
 
 	return &requestSender{
@@ -118,10 +118,10 @@ func (s *requestSender) Send() (res []byte, err error) {
 			return s.ScheduleRetry()
 		}
 
-		identity, _ := s.sender.WhoAmI()
+		address, _ := s.sender.WhoAmI()
 
 		s.logger.WithFields(log.Fields{
-			"local":       identity,
+			"local":       address,
 			"destination": s.destination,
 			"service":     s.service,
 			"endpoint":    s.endpoint,
@@ -132,10 +132,10 @@ func (s *requestSender) Send() (res []byte, err error) {
 		return nil, errors.New("max retries exceeded")
 	case <-ctx.Done(): // request timed out
 
-		identity, _ := s.sender.WhoAmI()
+		address, _ := s.sender.WhoAmI()
 
 		s.logger.WithFields(log.Fields{
-			"local":       identity,
+			"local":       address,
 			"destination": s.destination,
 			"service":     s.service,
 			"endpoint":    s.endpoint,

options.go

@@ -28,8 +28,10 @@ import (
 	log "github.com/uber-common/bark"
 	"github.com/uber/ringpop-go/hashring"
 	"github.com/uber/ringpop-go/logging"
+	"github.com/uber/ringpop-go/membership"
 	"github.com/uber/ringpop-go/shared"
 	"github.com/uber/ringpop-go/swim"
+	"github.com/uber/ringpop-go/util"
 )
 
 type configuration struct {
@@ -52,6 +54,9 @@ type configuration struct {
 	// number of labels and the size of key and value can be configured.
 	LabelLimits swim.LabelOptions
 
+	// InitialLabels configures the initial labels.
+	InitialLabels swim.LabelMap
+
 	// SelfEvict holds the settings with regards to self eviction
 	SelfEvict swim.SelfEvictOptions
 }
@@ -88,8 +93,8 @@ func checkOptions(rp *Ringpop) []error {
 	if rp.channel == nil {
 		errs = append(errs, errors.New("channel is required"))
 	}
-	if rp.identityResolver == nil {
-		errs = append(errs, errors.New("identity resolver is nil"))
+	if rp.addressResolver == nil {
+		errs = append(errs, errors.New("address resolver is nil"))
 	}
 	return errs
 }
@@ -173,37 +178,55 @@ func Statter(s log.StatsReporter) Option {
 	}
 }
 
-// Identity is used to specify a static hostport string as this Ringpop
-// instance's identity.
+// Identity can be used to specify a custom string as the unique identifier for
+// this node. The identity should be unique amongst other Ringpop instances; it
+// is used in the hashring.
+//
+// By default, the hostport/address of the node is used as the identity in the
+// hashring. An error is thrown if a hostport is manually specified using this
+// option, as this would lead to unexpected behaviour. If you want to override
+// the node's listening address, use the `Address` option.
+func Identity(identity string) Option {
+	return func(r *Ringpop) error {
+		if util.HostportPattern.MatchString(identity) {
+			return ErrInvalidIdentity
+		}
+		r.config.InitialLabels[membership.IdentityLabelKey] = identity
+		return nil
+	}
+}
+
+// Address is used to specify a static hostport string as this Ringpop
+// instance's address.
 //
 // Example:
 //
 //     ringpop.New("my-app",
 //         ringpop.Channel(myChannel),
-//         ringpop.Identity("10.32.12.2:21130"),
+//         ringpop.Address("10.32.12.2:21130"),
 //     )
 //
-// You should make sure the identity matches the listening address of the
+// You should make sure the address matches the listening address of the
 // TChannel object.
 //
-// By default, you do not need to provide an identity. If you do not provide
-// one, the identity will be resolved automatically by the default resolver.
-func Identity(hostport string) Option {
-	return IdentityResolverFunc(func() (string, error) {
-		return hostport, nil
+// By default, you do not need to provide an address. If you do not provide
+// one, the address will be resolved automatically by the default resolver.
+func Address(address string) Option {
+	return AddressResolverFunc(func() (string, error) {
+		return address, nil
 	})
 }
 
-// IdentityResolver is a function that returns the listen interface/port
-// that Ringpop should identify as.
-type IdentityResolver func() (string, error)
+// AddressResolver is a function that returns the listen interface/port
+// that Ringpop should use as its address.
+type AddressResolver func() (string, error)
 
-// IdentityResolverFunc is used to specify a function that will called when
-// the Ringpop instance needs to resolve its identity (typically, on
+// AddressResolverFunc is used to specify a function that will be called when
+// the Ringpop instance needs to resolve its address (typically, on
 // bootstrap).
-func IdentityResolverFunc(resolver IdentityResolver) Option {
+func AddressResolverFunc(resolver AddressResolver) Option {
 	return func(r *Ringpop) error {
-		r.identityResolver = resolver
+		r.addressResolver = resolver
 		return nil
 	}
 }
@@ -339,9 +362,9 @@ func defaultClock(r *Ringpop) error {
 	return Clock(clock.New())(r)
 }
 
-// defaultIdentityResolver sets the default identityResolver
-func defaultIdentityResolver(r *Ringpop) error {
-	r.identityResolver = r.channelIdentityResolver
+// defaultAddressResolver sets the default addressResolver
+func defaultAddressResolver(r *Ringpop) error {
+	r.addressResolver = r.channelAddressResolver
 	return nil
 }
 
@@ -378,7 +401,7 @@ func defaultRingChecksumStatPeriod(r *Ringpop) error {
 // can be overridden at runtime.
 var defaultOptions = []Option{
 	defaultClock,
-	defaultIdentityResolver,
+	defaultAddressResolver,
 	defaultLogLevels,
 	defaultStatter,
 	defaultMembershipChecksumStatPeriod,