ssh/connection.go: rename SSHTransfer receiver var

chrisd8088 · chrisd8088 · commit 31fdc3e6a70e · 2024-11-04T14:15:17.000-08:00
In PR git-lfs#4446 we defined a new SSHTransfer structure and a set of methods for it in our ssh/connection.go source file, and used the name "tr" for the receiver variables of those methods. Later, in commit 5dbbf13 of PR git-lfs#5674, we imported our "tr" message translation package into the same source file in order to format and localize an error message generated by the startConnection() function. Because this function is not one of the methods of the SSHTransfer structure there was no conflict with the "tr" receiver variables of those methods. However, in subsequent commits in this PR we expect to revise one of the SSHTransfer structure's methods to output an error message, and will want to use the Get() method of the "tr" package's global Tr variable. We are not able to do this with the current name of the "tr" receiver variable as it masks the "tr" package name within the method's scope. Therefore we now rename all our "tr" receiver variables to "st" in the ssh/connection.go source file, so as to avoid any namespace conflicts with our "tr" package.
diff --git a/ssh/connection.go b/ssh/connection.go
@@ -90,82 +90,82 @@ func startConnection(id int, osEnv config.Environment, gitEnv config.Environment
 
 // Connection returns the nth connection (starting from 0) in this transfer
 // instance or nil if there is no such item.
-func (tr *SSHTransfer) IsMultiplexingEnabled() bool {
-	return tr.multiplexing
+func (st *SSHTransfer) IsMultiplexingEnabled() bool {
+	return st.multiplexing
 }
 
 // Connection returns the nth connection (starting from 0) in this transfer
 // instance if it is initialized and otherwise initializes a new connection and
 // saves it in the nth position.  In all cases, nil is returned if n is greater
 // than the maximum number of connections.
-func (tr *SSHTransfer) Connection(n int) (*PktlineConnection, error) {
-	tr.lock.RLock()
-	if n >= len(tr.conn) {
-		tr.lock.RUnlock()
+func (st *SSHTransfer) Connection(n int) (*PktlineConnection, error) {
+	st.lock.RLock()
+	if n >= len(st.conn) {
+		st.lock.RUnlock()
 		return nil, nil
 	}
-	if tr.conn[n] != nil {
-		defer tr.lock.RUnlock()
-		return tr.conn[n], nil
+	if st.conn[n] != nil {
+		defer st.lock.RUnlock()
+		return st.conn[n], nil
 	}
-	tr.lock.RUnlock()
+	st.lock.RUnlock()
 
-	tr.lock.Lock()
-	defer tr.lock.Unlock()
-	if tr.conn[n] != nil {
-		return tr.conn[n], nil
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	if st.conn[n] != nil {
+		return st.conn[n], nil
 	}
-	conn, _, err := tr.spawnConnection(n)
+	conn, _, err := st.spawnConnection(n)
 	if err != nil {
 		return nil, err
 	}
-	tr.conn[n] = conn
+	st.conn[n] = conn
 	return conn, nil
 }
 
 // ConnectionCount returns the number of connections this object has.
-func (tr *SSHTransfer) ConnectionCount() int {
-	tr.lock.RLock()
-	defer tr.lock.RUnlock()
-	return len(tr.conn)
+func (st *SSHTransfer) ConnectionCount() int {
+	st.lock.RLock()
+	defer st.lock.RUnlock()
+	return len(st.conn)
 }
 
 // SetConnectionCount sets the number of connections to the specified number.
-func (tr *SSHTransfer) SetConnectionCount(n int) error {
-	tr.lock.Lock()
-	defer tr.lock.Unlock()
-	return tr.setConnectionCount(n)
+func (st *SSHTransfer) SetConnectionCount(n int) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	return st.setConnectionCount(n)
 }
 
 // SetConnectionCountAtLeast sets the number of connections to be not less than
 // the specified number.
-func (tr *SSHTransfer) SetConnectionCountAtLeast(n int) error {
-	tr.lock.Lock()
-	defer tr.lock.Unlock()
-	count := len(tr.conn)
+func (st *SSHTransfer) SetConnectionCountAtLeast(n int) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	count := len(st.conn)
 	if n <= count {
 		return nil
 	}
-	return tr.setConnectionCount(n)
+	return st.setConnectionCount(n)
 }
 
-func (tr *SSHTransfer) spawnConnection(n int) (*PktlineConnection, string, error) {
-	conn, _, controlPath, err := startConnection(n, tr.osEnv, tr.gitEnv, tr.meta, tr.operation, tr.controlPath)
+func (st *SSHTransfer) spawnConnection(n int) (*PktlineConnection, string, error) {
+	conn, _, controlPath, err := startConnection(n, st.osEnv, st.gitEnv, st.meta, st.operation, st.controlPath)
 	if err != nil {
 		tracerx.Printf("failed to spawn pure SSH connection (#%d): %s", n, err)
 		return nil, "", err
 	}
 	return conn, controlPath, err
 }
 
-func (tr *SSHTransfer) setConnectionCount(n int) error {
-	count := len(tr.conn)
+func (st *SSHTransfer) setConnectionCount(n int) error {
+	count := len(st.conn)
 	if n < count {
 		tn := n
 		if tn == 0 {
 			tn = 1
 		}
-		for i, item := range tr.conn[tn:count] {
+		for i, item := range st.conn[tn:count] {
 			if item == nil {
 				tracerx.Printf("skipping uninitialized lazy pure SSH connection (#%d) (resetting total from %d to %d)", i, count, n)
 				continue
@@ -175,33 +175,33 @@ func (tr *SSHTransfer) setConnectionCount(n int) error {
 				return err
 			}
 		}
-		tr.conn = tr.conn[0:tn]
+		st.conn = st.conn[0:tn]
 	} else if n > count {
 		for i := count; i < n; i++ {
 			if i == 0 {
-				conn, controlPath, err := tr.spawnConnection(i)
+				conn, controlPath, err := st.spawnConnection(i)
 				if err != nil {
 					return err
 				}
-				tr.conn = append(tr.conn, conn)
-				tr.controlPath = controlPath
+				st.conn = append(st.conn, conn)
+				st.controlPath = controlPath
 			} else {
-				tr.conn = append(tr.conn, nil)
+				st.conn = append(st.conn, nil)
 			}
 		}
 	}
 	if n == 0 && count > 0 {
 		tracerx.Printf("terminating pure SSH connection (#0) (resetting total from %d to %d)", count, n)
-		if err := tr.conn[0].End(); err != nil {
+		if err := st.conn[0].End(); err != nil {
 			return err
 		}
-		tr.conn = nil
-		tr.controlPath = ""
+		st.conn = nil
+		st.controlPath = ""
 	}
 	return nil
 }
 
-func (tr *SSHTransfer) Shutdown() error {
+func (st *SSHTransfer) Shutdown() error {
 	tracerx.Printf("shutting down pure SSH connections")
-	return tr.SetConnectionCount(0)
+	return st.SetConnectionCount(0)
 }
