transport: rename DialUpdateKind enum values

core/transport/transport.go

@@ -136,21 +136,22 @@ type DialUpdater interface {
 type DialUpdateKind int
 
 const (
-	// DialFailed indicates dial failed.
-	DialFailed DialUpdateKind = iota
-	// DialSuccessful indicates dial succeeded.
-	DialSuccessful
-	// TCPConnectionEstablished indicates successful completion of the TCP 3-way handshake
-	TCPConnectionEstablished
+	// UpdateKindDialFailed indicates dial failed.
+	UpdateKindDialFailed DialUpdateKind = iota
+	// UpdateKindDialSuccessful indicates dial succeeded.
+	UpdateKindDialSuccessful
+	// UpdateKindTCPConnectionEstablished indicates successful completion of the TCP 3-way
+	// handshake
+	UpdateKindTCPConnectionEstablished
 )
 
 func (k DialUpdateKind) String() string {
 	switch k {
-	case DialFailed:
+	case UpdateKindDialFailed:
 		return "DialFailed"
-	case DialSuccessful:
+	case UpdateKindDialSuccessful:
 		return "DialSuccessful"
-	case TCPConnectionEstablished:
+	case UpdateKindTCPConnectionEstablished:
 		return "TCPConnectionEstablished"
 	default:
 		return fmt.Sprintf("DialUpdateKind<Unknown-%d>", k)

p2p/net/swarm/dial_worker.go

@@ -325,7 +325,7 @@ loop:
 
 			// TCP Connection has been established. Wait for connection upgrade on this address
 			// before making new dials.
-			if res.Kind == tpt.TCPConnectionEstablished {
+			if res.Kind == tpt.UpdateKindTCPConnectionEstablished {
 				// Only wait for public addresses to complete dialing since private dials
 				// are quick any way
 				if manet.IsPublicAddr(res.Addr) {

p2p/net/swarm/dial_worker_test.go

@@ -1116,7 +1116,7 @@ func TestDialWorkerLoopTCPConnUpgradeWait(t *testing.T) {
 	// Wait a bit to let the loop make the dial attempt to a1
 	time.Sleep(1 * time.Second)
 	// Send conn established for a1
-	worker.resch <- transport.DialUpdate{Kind: transport.TCPConnectionEstablished, Addr: a1}
+	worker.resch <- transport.DialUpdate{Kind: transport.UpdateKindTCPConnectionEstablished, Addr: a1}
 	// Dial to a2 shouldn't happen even if a2 is scheduled to dial by now
 	cl.AdvanceBy(290 * time.Millisecond)
 	select {

p2p/net/swarm/limiter.go

@@ -211,9 +211,9 @@ func (dl *dialLimiter) executeDial(j *dialJob) {
 	defer cancel()
 
 	con, err := dl.dialFunc(dctx, j.peer, j.addr, j.resp)
-	kind := transport.DialSuccessful
+	kind := transport.UpdateKindDialSuccessful
 	if err != nil {
-		kind = transport.DialFailed
+		kind = transport.UpdateKindDialFailed
 	}
 	select {
 	case j.resp <- transport.DialUpdate{Kind: kind, Conn: con, Addr: j.addr, Err: err}:

p2p/transport/tcp/tcp.go

@@ -219,7 +219,7 @@ func (t *TcpTransport) dialWithScope(ctx context.Context, raddr ma.Multiaddr, p
 	}
 	if updCh != nil {
 		select {
-		case updCh <- transport.DialUpdate{Kind: transport.TCPConnectionEstablished, Addr: raddr}:
+		case updCh <- transport.DialUpdate{Kind: transport.UpdateKindTCPConnectionEstablished, Addr: raddr}:
 		default:
 			// It is better to skip the update than to delay upgrading the connection
 		}

p2p/transport/tcp/tcp_test.go

@@ -168,7 +168,7 @@ func TestDialWithUpdates(t *testing.T) {
 	updCh := make(chan transport.DialUpdate, 1)
 	conn, err := tb.DialWithUpdates(context.Background(), ln.Multiaddr(), peerA, updCh)
 	upd := <-updCh
-	require.Equal(t, upd.Kind, transport.TCPConnectionEstablished)
+	require.Equal(t, upd.Kind, transport.UpdateKindTCPConnectionEstablished)
 	require.NotNil(t, conn)
 	require.NoError(t, err)
 
@@ -191,7 +191,7 @@ func TestDialWithUpdates(t *testing.T) {
 	// This dial will fail as acceptAndClose will not upgrade the connection
 	conn, err = tb.DialWithUpdates(context.Background(), li.Multiaddr(), peerA, updCh)
 	upd = <-updCh
-	require.Equal(t, upd.Kind, transport.TCPConnectionEstablished)
+	require.Equal(t, upd.Kind, transport.UpdateKindTCPConnectionEstablished)
 	require.Nil(t, conn)
 	require.Error(t, err)
 }