webnet/tailscale
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

all: rename variables with lowercase-l/uppercase-I

Browse Source 
See http://go/no-ell

Signed-off-by: Alex Chan <alexc@tailscale.com>

Updates #cleanup

Change-Id: I8c976b51ce7a60f06315048b1920516129cc1d5d
This commit is contained in:
Alex Chan
2025-11-17 18:13:44 +00:00
committed by Alex Chan
parent 9048ea25db
commit c2e474e729
81 changed files with 923 additions and 923 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drive/driveimpl/connlistener.go
+12 -12
View File
@@ -25,12 +25,12 @@ func newConnListener() *connListener {
}
}
func (l *connListener) Accept() (net.Conn, error) {
func (ln *connListener) Accept() (net.Conn, error) {
select {
case <-l.closedCh:
case <-ln.closedCh:
// TODO(oxtoacart): make this error match what a regular net.Listener does
return nil, syscall.EINVAL
case conn := <-l.ch:
case conn := <-ln.ch:
return conn, nil
}
}
@@ -38,32 +38,32 @@ func (l *connListener) Accept() (net.Conn, error) {
// Addr implements net.Listener. This always returns nil. It is assumed that
// this method is currently unused, so it logs a warning if it ever does get
// called.
func (l *connListener) Addr() net.Addr {
func (ln *connListener) Addr() net.Addr {
log.Println("warning: unexpected call to connListener.Addr()")
return nil
}
func (l *connListener) Close() error {
l.closeMu.Lock()
defer l.closeMu.Unlock()
func (ln *connListener) Close() error {
ln.closeMu.Lock()
defer ln.closeMu.Unlock()
select {
case <-l.closedCh:
case <-ln.closedCh:
// Already closed.
return syscall.EINVAL
default:
// We don't close l.ch because someone maybe trying to send to that,
// which would cause a panic.
close(l.closedCh)
close(ln.closedCh)
return nil
}
}
func (l *connListener) HandleConn(c net.Conn, remoteAddr net.Addr) error {
func (ln *connListener) HandleConn(c net.Conn, remoteAddr net.Addr) error {
select {
case <-l.closedCh:
case <-ln.closedCh:
return syscall.EINVAL
case l.ch <- &connWithRemoteAddr{Conn: c, remoteAddr: remoteAddr}:
case ln.ch <- &connWithRemoteAddr{Conn: c, remoteAddr: remoteAddr}:
// Connection has been accepted.
}
return nil
drive/driveimpl/connlistener_test.go
+3 -3
View File
@@ -10,20 +10,20 @@ import (
)
func TestConnListener(t *testing.T) {
l, err := net.Listen("tcp", "127.0.0.1:")
ln, err := net.Listen("tcp", "127.0.0.1:")
if err != nil {
t.Fatalf("failed to Listen: %s", err)
}
cl := newConnListener()
// Test that we can accept a connection
cc, err := net.Dial("tcp", l.Addr().String())
cc, err := net.Dial("tcp", ln.Addr().String())
if err != nil {
t.Fatalf("failed to Dial: %s", err)
}
defer cc.Close()
sc, err := l.Accept()
sc, err := ln.Accept()
if err != nil {
t.Fatalf("failed to Accept: %s", err)
}
drive/driveimpl/drive_test.go
+9 -9
View File
@@ -467,14 +467,14 @@ func newSystem(t *testing.T) *system {
tstest.ResourceCheck(t)
fs := newFileSystemForLocal(log.Printf, nil)
l, err := net.Listen("tcp", "127.0.0.1:0")
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("failed to Listen: %s", err)
}
t.Logf("FileSystemForLocal listening at %s", l.Addr())
t.Logf("FileSystemForLocal listening at %s", ln.Addr())
go func() {
for {
conn, err := l.Accept()
conn, err := ln.Accept()
if err != nil {
t.Logf("Accept: %v", err)
return
@@ -483,11 +483,11 @@ func newSystem(t *testing.T) *system {
}
}()
client := gowebdav.NewAuthClient(fmt.Sprintf("http://%s", l.Addr()), &noopAuthorizer{})
client := gowebdav.NewAuthClient(fmt.Sprintf("http://%s", ln.Addr()), &noopAuthorizer{})
client.SetTransport(&http.Transport{DisableKeepAlives: true})
s := &system{
t: t,
local: &local{l: l, fs: fs},
local: &local{l: ln, fs: fs},
client: client,
remotes: make(map[string]*remote),
}
@@ -496,11 +496,11 @@ func newSystem(t *testing.T) *system {
}
func (s *system) addRemote(name string) string {
l, err := net.Listen("tcp", "127.0.0.1:0")
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
s.t.Fatalf("failed to Listen: %s", err)
}
s.t.Logf("Remote for %v listening at %s", name, l.Addr())
s.t.Logf("Remote for %v listening at %s", name, ln.Addr())
fileServer, err := NewFileServer()
if err != nil {
@@ -510,14 +510,14 @@ func (s *system) addRemote(name string) string {
s.t.Logf("FileServer for %v listening at %s", name, fileServer.Addr())
r := &remote{
l: l,
l: ln,
fileServer: fileServer,
fs: NewFileSystemForRemote(log.Printf),
shares: make(map[string]string),
permissions: make(map[string]drive.Permission),
}
r.fs.SetFileServerAddr(fileServer.Addr())
go http.Serve(l, r)
go http.Serve(ln, r)
s.remotes[name] = r
remotes := make([]*drive.Remote, 0, len(s.remotes))
drive/driveimpl/fileserver.go
+7 -7
View File
@@ -20,7 +20,7 @@ import (
// It's typically used in a separate process from the actual Taildrive server to
// serve up files as an unprivileged user.
type FileServer struct {
l net.Listener
ln net.Listener
secretToken string
shareHandlers map[string]http.Handler
sharesMu sync.RWMutex
@@ -41,10 +41,10 @@ type FileServer struct {
// called.
func NewFileServer() (*FileServer, error) {
// path := filepath.Join(os.TempDir(), fmt.Sprintf("%v.socket", uuid.New().String()))
// l, err := safesocket.Listen(path)
// ln, err := safesocket.Listen(path)
// if err != nil {
// TODO(oxtoacart): actually get safesocket working in more environments (MacOS Sandboxed, Windows, ???)
l, err := net.Listen("tcp", "127.0.0.1:0")
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return nil, fmt.Errorf("listen: %w", err)
}
@@ -55,7 +55,7 @@ func NewFileServer() (*FileServer, error) {
}
return &FileServer{
l: l,
ln: ln,
secretToken: secretToken,
shareHandlers: make(map[string]http.Handler),
}, nil
@@ -74,12 +74,12 @@ func generateSecretToken() (string, error) {
// Addr returns the address at which this FileServer is listening. This
// includes the secret token in front of the address, delimited by a pipe |.
func (s *FileServer) Addr() string {
return fmt.Sprintf("%s|%s", s.secretToken, s.l.Addr().String())
return fmt.Sprintf("%s|%s", s.secretToken, s.ln.Addr().String())
}
// Serve() starts serving files and blocks until it encounters a fatal error.
func (s *FileServer) Serve() error {
return http.Serve(s.l, s)
return http.Serve(s.ln, s)
}
// LockShares locks the map of shares in preparation for manipulating it.
@@ -162,5 +162,5 @@ func (s *FileServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
}
func (s *FileServer) Close() error {
return s.l.Close()
return s.ln.Close()
}