Revert "feat: add logger interface (#17)"

This reverts commit bb5f31e.

cmd.go → cmd/cmd.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"fmt"
@@ -31,7 +31,7 @@ func ensureDirs(path string) error {
 	return nil
 }
 
-func run(r io.Reader, w io.Writer, args ...string) error {
+func run(r io.Reader, w io.Writer, args []string) error {
 	if len(args) != 2 {
 		return fmt.Errorf("expected 2 arguments, got %d", len(args))
 	}
@@ -50,20 +50,20 @@ func run(r io.Reader, w io.Writer, args ...string) error {
 		return err
 	}
 	umask := setPermissions(gitdir)
-	handler := transfer.NewPktline(r, w, logger)
+	handler := transfer.NewPktline(r, w)
 	for _, cap := range capabilities {
 		if err := handler.WritePacketText(cap); err != nil {
-			logger.Log("error sending capability", "cap", cap, "err", err)
+			transfer.Logf("error sending capability: %s: %v", cap, err)
 		}
 	}
 	if err := handler.WriteFlush(); err != nil {
-		logger.Log("error flushing capabilities", "err", err)
+		transfer.Logf("error flushing capabilities: %v", err)
 	}
 	now := time.Now()
-	logger.Log("umask", "umask", umask)
+	transfer.Logf("umask %o", umask)
 	backend := local.New(lfsPath, umask, &now)
-	p := transfer.NewProcessor(handler, backend, logger)
-	defer logger.Log("done processing commands")
+	p := transfer.NewProcessor(handler, backend)
+	defer transfer.Log("done processing commands")
 	switch op {
 	case "upload":
 		return p.ProcessCommands(transfer.UploadOperation)
@@ -94,17 +94,17 @@ func Command(stdin io.Reader, stdout io.Writer, stderr io.Writer, args ...string
 	errc := make(chan error, 1)
 
 	setup(done)
-	logger.Log("git-lfs-transfer", "version", "v1")
-	defer logger.Log("git-lfs-transfer completed")
+	transfer.Logf("git-lfs-transfer %s", "v1")
+	defer transfer.Log("git-lfs-transfer completed")
 	go func() {
-		errc <- run(stdin, stdout, args...)
+		errc <- run(stdin, stdout, args)
 	}()
 
 	select {
 	case s := <-done:
-		logger.Log("signal received", "signal", s)
+		transfer.Logf("signal %q received", s)
 	case err := <-errc:
-		logger.Log("done running")
+		transfer.Log("done running")
 		fmt.Fprintln(stderr, Usage())
 		fmt.Fprintln(stderr, err)
 		if err != nil {

cmd_other.go → cmd/cmd_other.go

@@ -1,7 +1,7 @@
 //go:build !(darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris)
 // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris
 
-package main
+package cmd
 
 import (
 	"os"

cmd_unix.go → cmd/cmd_unix.go

@@ -1,7 +1,7 @@
 //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
-package main
+package cmd
 
 import (
 	"os"

internal/local/backend.go

@@ -72,6 +72,7 @@ func (l *LocalBackend) FinishUpload(state interface{}, _ transfer.Args) error {
 	case *UploadState:
 		destPath := oidExpectedPath(l.lfsPath, state.Oid)
 		parent := filepath.Dir(destPath)
+		transfer.Logf("finishing upload of %s at %s", destPath, parent)
 		if err := os.MkdirAll(parent, 0777); err != nil {
 			return err
 		}
@@ -105,6 +106,7 @@ func (l *LocalBackend) StartUpload(oid string, r io.Reader, _ transfer.Args) (in
 	if r == nil {
 		return nil, fmt.Errorf("%w: received null data", transfer.ErrMissingData)
 	}
+	transfer.Logf("start uploading %s", oid)
 	tempDir := filepath.Join(l.lfsPath, "incomplete")
 	randBytes := make([]byte, 12)
 	if _, err := rand.Read(randBytes); err != nil {
@@ -140,6 +142,7 @@ func (l *LocalBackend) Verify(oid string, args transfer.Args) (transfer.Status,
 		return nil, err
 	}
 	if stat.Size() != int64(expectedSize) {
+		transfer.Logf("size mismatch, expected %d, got %d", expectedSize, stat.Size())
 		return transfer.NewFailureStatus(transfer.StatusConflict, "size mismatch"), nil
 	}
 	return transfer.SuccessStatus(), nil
@@ -166,7 +169,7 @@ func (l *localLockBackend) Timestamp() *time.Time {
 }
 
 // Create implements main.LockBackend.
-func (l *localLockBackend) Create(path, _ string) (transfer.Lock, error) {
+func (l *localLockBackend) Create(path, refname string) (transfer.Lock, error) {
 	id := localBackendLock{}.HashFor(path)
 	var b bytes.Buffer
 	b.WriteString(fmt.Sprintf("%s:%d:", LocalBackendLockVersion, l.Timestamp().Unix()))
@@ -239,10 +242,12 @@ func (l *localLockBackend) Range(_ string, _ int, f func(l transfer.Lock) error)
 	if err != nil {
 		return "", err
 	}
+	transfer.Logf("found %d locks", len(data))
 	sort.Slice(data, func(i, j int) bool {
 		return data[i].Name() < data[j].Name()
 	})
 	for _, lf := range data {
+		transfer.Logf("found lock %s", lf.Name())
 		var lock transfer.Lock
 		lock, err = l.FromID(lf.Name())
 		if err != nil {

internal/local/backend_unix.go

@@ -19,6 +19,7 @@ func (l *LocalBackend) FixPermissions(path string) (transfer.Status, error) {
 	if err != nil {
 		return nil, err
 	}
+	transfer.Logf("settings permissions of %s to %o", path, 0777&^l.umask)
 	if err := os.Chmod(path, 0777&^l.umask); err != nil {
 		return nil, err
 	}

main.go

@@ -5,37 +5,19 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/charmbracelet/git-lfs-transfer/cmd"
 	"github.com/charmbracelet/git-lfs-transfer/transfer"
-	"github.com/rubyist/tracerx"
 )
 
-type tracerxLogger struct{}
-
-// Log logs the given arguments if Debug is true.
-func (*tracerxLogger) Log(msg string, kv ...interface{}) {
-	format := msg
-	for i := 0; i < len(kv); i += 2 {
-		format += " %s=%v"
-	}
-	tracerx.Printf(format, kv...)
-}
-
-var logger = new(tracerxLogger)
-
-func init() {
-	tracerx.DefaultKey = "GIT"
-	tracerx.Prefix = "trace git-lfs-transfer: "
-}
-
 func main() {
 	args := os.Args
 	if len(args) < 2 {
-		fmt.Fprintln(os.Stderr, Usage())
+		fmt.Fprintln(os.Stderr, cmd.Usage())
 		fmt.Fprintf(os.Stderr, "expected 2 arguments, got %d\n", len(args)-1)
 		os.Exit(1)
 	}
-	if err := Command(os.Stdin, os.Stdout, os.Stderr, args[1:]...); err != nil {
-		fmt.Fprintf(os.Stderr, Usage())
+	if err := cmd.Command(os.Stdin, os.Stdout, os.Stderr, args[1:]...); err != nil {
+		fmt.Fprintf(os.Stderr, cmd.Usage())
 		fmt.Fprintln(os.Stderr)
 		fmt.Fprintln(os.Stderr, err)
 		switch {

transfer/args.go

@@ -29,6 +29,7 @@ func ParseArgs(parts []string) (Args, error) {
 		key, value := parts[0], parts[1]
 		args[key] = value
 	}
+	Logf("args: %d %v", len(args), args)
 	return args, nil
 }
 

transfer/log.go

@@ -1,14 +1,20 @@
 package transfer
 
-// Logger is a logging interface.
-type Logger interface {
-	// Log logs the given message and structured arguments.
-	Log(msg string, kv ...interface{})
-}
+import (
+	"github.com/rubyist/tracerx"
+)
 
-type noopLogger struct{}
+var (
+	// Debug is the debug flag.
+	Debug = false
+)
 
-var _ Logger = (*noopLogger)(nil)
+// Log logs the given arguments if Debug is true.
+func Log(v ...interface{}) {
+	tracerx.Printf("%v", v...)
+}
 
-// Log implements Logger.
-func (*noopLogger) Log(string, ...interface{}) {}
+// Logf logs the given arguments if Debug is true.
+func Logf(format string, v ...interface{}) {
+	tracerx.Printf(format, v...)
+}

transfer/oid.go

@@ -34,7 +34,7 @@ func (p Pointer) IsValid() bool {
 	return true
 }
 
-// RelativePath returns the relative storage path of the pointer.
+// RelativePath returns the relative storage path of the pointer
 func (p Pointer) RelativePath() string {
 	if len(p.Oid) < 5 {
 		return p.Oid

transfer/pktline.go

@@ -30,75 +30,70 @@ const (
 // PktLine is a Git packet line handler.
 type Pktline struct {
 	*pktline.Pktline
-	r      io.Reader
-	w      io.Writer
-	logger Logger
+	r io.Reader
+	w io.Writer
 }
 
 // NewPktline creates a new Git packet line handler.
-func NewPktline(r io.Reader, w io.Writer, logger Logger) *Pktline {
-	if logger == nil {
-		logger = new(noopLogger)
-	}
+func NewPktline(r io.Reader, w io.Writer) *Pktline {
 	return &Pktline{
 		Pktline: pktline.NewPktline(r, w),
 		r:       r,
 		w:       w,
-		logger:  logger,
 	}
 }
 
 // SendError sends an error msg.
 func (p *Pktline) SendError(status uint32, message string) error {
-	p.logger.Log("sending error status", "code", status, "msg", message)
+	Logf("sending error: %d %s", status, message)
 	if err := p.WritePacketText(fmt.Sprintf("status %03d", status)); err != nil {
-		p.logger.Log("failed to write packet", "err", err)
+		Logf("error writing status: %s", err)
 	}
 	if err := p.WriteDelim(); err != nil {
-		p.logger.Log("failed to write delimiter", "err", err)
+		Logf("error writing delim: %s", err)
 	}
 	if err := p.WritePacketText(message); err != nil {
-		p.logger.Log("failed to write message", "err", err)
+		Logf("error writing message: %s", err)
 	}
 	return p.WriteFlush()
 }
 
 // SendStatus sends a status message.
 func (p *Pktline) SendStatus(status Status) error {
-	p.logger.Log("sending status", "code", status)
+	Logf("sending status: %s", status)
 	if err := p.WritePacketText(fmt.Sprintf("status %03d", status.Code())); err != nil {
-		p.logger.Log("failed to write status", "err", err)
+		Logf("error writing status: %s", err)
 	}
 	if args := status.Args(); len(args) > 0 {
 		for _, arg := range args {
 			if err := p.WritePacketText(arg); err != nil {
-				p.logger.Log("failed to write argument", "arg", arg, "err", err)
+				Logf("error writing arg: %s", err)
 			}
 		}
 	}
 	if msgs := status.Messages(); len(msgs) > 0 {
 		if err := p.WriteDelim(); err != nil {
-			p.logger.Log("failed to write delimiter", "err", err)
+			Logf("error writing delim: %s", err)
 		}
 		for _, msg := range msgs {
 			if err := p.WritePacketText(msg); err != nil {
-				p.logger.Log("failed to write message", "err", err)
+				Logf("error writing msg: %s", err)
 			}
 		}
 	} else if r := status.Reader(); r != nil {
-		p.logger.Log("sending reader")
+		Logf("sending reader")
 		// Close reader if it implements io.Closer.
 		if c, ok := r.(io.Closer); ok {
 			defer c.Close() // nolint: errcheck
 		}
 		if err := p.WriteDelim(); err != nil {
-			p.logger.Log("failed to write delimiter", "err", err)
+			Logf("error writing delim: %v", err)
 		}
 		w := p.Writer()
 		if _, err := io.Copy(w, r); err != nil {
-			p.logger.Log("failed to copy reader", "err", err)
+			Logf("error copying reader: %v", err)
 		}
-		defer p.logger.Log("done copying")
+		defer Logf("done copying")
 		return w.Flush()
 	}
 	return p.WriteFlush()