all repos

mugit @ e07d1c9622189c28b8c7cd48d7fe78de2c3fcb3a

馃惍 git server that your cow will love
12 files changed, 28 insertions(+), 26 deletions(-)
run errcheck
Author: Oleksandr Smirnov olexsmir@gmail.com
Committed at: 2026-05-09 19:31:54 +0300
Authored at: 2026-05-09 19:24:51 +0300
Change ID: ytpwwpmtxnsxmomsxkpnxsorzzqqxsuw
Parent: 3e7e955
M internal/cli/serve.go
路路路
        35
        35
         		mirrorer := mirror.NewWorker(c.cfg)

      
        36
        36
         		go func() {

      
        37
        37
         			slog.Info("starting mirroring worker")

      
        38
        
        -			mirrorer.Start(ctx)

      
        
        38
        +			if err := mirrorer.Start(ctx); err != nil {

      
        
        39
        +				slog.Error("failed to start mirrorer", "err", err)

      
        
        40
        +			}

      
        39
        41
         		}()

      
        40
        42
         	}

      
        41
        43
         

      
M internal/cli/ssh_shell.go
路路路
        45
        45
         	}

      
        46
        46
         

      
        47
        47
         	out := c.ssh.AuthorizedKeys(executablePath)

      
        48
        
        -	fmt.Fprint(os.Stdout, out)

      
        
        48
        +	_, _ = fmt.Fprint(os.Stdout, out)

      
        49
        49
         

      
        50
        50
         	return nil

      
        51
        51
         }

      
M internal/config/config_test.go
路路路
        79
        79
         func candidateFile(t *testing.T, name string) string {

      
        80
        80
         	t.Helper()

      
        81
        81
         	out := filepath.Join(t.TempDir(), name)

      
        82
        
        -	os.WriteFile(out, []byte("test"), 0o644)

      
        
        82
        +	_ = os.WriteFile(out, []byte("test"), 0o644)

      
        83
        83
         	return out

      
        84
        84
         }

      
M internal/git/config_test.go
路路路
        65
        65
         

      
        66
        66
         		// Write the default git description to the .git directory

      
        67
        67
         		descPath := filepath.Join(r.path, ".git", "description")

      
        68
        
        -		err := os.WriteFile(descPath, []byte(defaultDescription), 0o644)

      
        69
        
        -		is.Err(t, err, nil)

      
        
        68
        +		_ = os.WriteFile(descPath, []byte(defaultDescription), 0o644)

      
        70
        69
         

      
        71
        70
         		desc, err := r.open().Description()

      
        72
        71
         		is.Err(t, err, nil)

      
M internal/git/repo.go
路路路
        183
        183
         

      
        184
        184
         	// since after commit was shown on prev page, skip it

      
        185
        185
         	if after != "" {

      
        186
        
        -		ci.Next()

      
        
        186
        +		if _, err = ci.Next(); err != nil {

      
        
        187
        +			return nil, err

      
        
        188
        +		}

      
        187
        189
         	}

      
        188
        190
         

      
        189
        191
         	commits := make([]*Commit, 0, CommitsPage)

      
        190
        
        -	ci.ForEach(func(c *object.Commit) error {

      
        
        192
        +	err = ci.ForEach(func(c *object.Commit) error {

      
        191
        193
         		if len(commits) == CommitsPage {

      
        192
        194
         			return storer.ErrStop

      
        193
        195
         		}

      
        194
        196
         		commits = append(commits, newCommit(c))

      
        195
        197
         		return nil

      
        196
        198
         	})

      
        197
        
        -

      
        198
        
        -	return commits, nil

      
        
        199
        +	return commits, err

      
        199
        200
         }

      
        200
        201
         

      
        201
        202
         func (g *Repo) LastCommit() (*Commit, error) {

      
M internal/git/tree.go
路路路
        120
        120
         	if err != nil {

      
        121
        121
         		return nil, fmt.Errorf("file reader: %w", err)

      
        122
        122
         	}

      
        123
        
        -	defer reader.Close()

      
        
        123
        +	defer func() { _ = reader.Close() }()

      
        124
        124
         

      
        125
        125
         	content, err := io.ReadAll(reader)

      
        126
        126
         	if err != nil {

      路路路
        156
        156
         	if err != nil {

      
        157
        157
         		return "", fmt.Errorf("last file commit for %q: %w", fpath, err)

      
        158
        158
         	}

      
        159
        
        -	defer output.Close()

      
        
        159
        +	defer func() { _ = output.Close() }()

      
        160
        160
         

      
        161
        161
         	raw, err := io.ReadAll(output)

      
        162
        162
         	if err != nil {

      路路路
        195
        195
         	if err != nil {

      
        196
        196
         		return nil, err

      
        197
        197
         	}

      
        198
        
        -	defer output.Close() // Ensure the git process is properly cleaned up

      
        
        198
        +	defer func() { _ = output.Close() }()

      
        199
        199
         

      
        200
        200
         	var current logCommit

      
        201
        201
         	reader := bufio.NewReader(output)

      
M internal/handlers/feed.go
路路路
        96
        96
         	}

      
        97
        97
         

      
        98
        98
         	w.Header().Set("Content-Type", "application/rss+xml")

      
        99
        
        -	w.Write([]byte(xml.Header))

      
        
        99
        +	_, _ = w.Write([]byte(xml.Header))

      
        100
        100
         	if err := xml.NewEncoder(w).Encode(feed); err != nil {

      
        101
        101
         		h.write500(w, err)

      
        102
        102
         		return

      路路路
        140
        140
         	}

      
        141
        141
         

      
        142
        142
         	w.Header().Set("Content-Type", "application/rss+xml")

      
        143
        
        -	w.Write([]byte(xml.Header))

      
        
        143
        +	_, _ = w.Write([]byte(xml.Header))

      
        144
        144
         	if err := xml.NewEncoder(w).Encode(feed); err != nil {

      
        145
        145
         		h.write500(w, err)

      
        146
        146
         		return

      
M internal/handlers/git.go
路路路
        27
        27
         

      
        28
        28
         		w.WriteHeader(http.StatusOK)

      
        29
        29
         		if err := repo.InfoRefs(r.Context(), gitProtocol, w); err != nil {

      
        30
        
        -			git.PackError(w, err.Error())

      
        
        30
        +			_ = git.PackError(w, err.Error())

      
        31
        31
         			slog.Error("git: info/refs", "err", err)

      
        32
        32
         			return

      
        33
        33
         		}

      路路路
        64
        64
         			slog.Error("git: failed to create gzip reader", "err", err)

      
        65
        65
         			return

      
        66
        66
         		}

      
        67
        
        -		defer gzipReader.Close()

      
        
        67
        +		defer func() { _ = gzipReader.Close() }()

      
        68
        68
         		bodyReader = gzipReader

      
        69
        69
         	}

      
        70
        70
         

      路路路
        74
        74
         

      
        75
        75
         	w.WriteHeader(http.StatusOK)

      
        76
        76
         	if err := repo.UploadPack(r.Context(), true, gitProtocol, bodyReader, newFlushWriter(w)); err != nil {

      
        77
        
        -		git.PackError(w, err.Error())

      
        
        77
        +		_ = git.PackError(w, err.Error())

      
        78
        78
         		slog.Error("git: upload-pack", "err", err)

      
        79
        79
         		return

      
        80
        80
         	}

      路路路
        108
        108
         func (h *handlers) gitError(w http.ResponseWriter, code int, msg string) {

      
        109
        109
         	w.Header().Set("content-type", "text/plain; charset=UTF-8")

      
        110
        110
         	w.WriteHeader(code)

      
        111
        
        -	fmt.Fprintf(w, "%s\n", msg)

      
        
        111
        +	_, _ = fmt.Fprintf(w, "%s\n", msg)

      
        112
        112
         }

      
        113
        113
         

      
        114
        114
         func (h *handlers) openPublicRepo(name, ref string) (*git.Repo, error) {

      
M internal/handlers/repo.go
路路路
        255
        255
         

      
        256
        256
         	w.Header().Set("Content-Type", fc.Mime)

      
        257
        257
         	w.WriteHeader(http.StatusOK)

      
        258
        
        -	w.Write(fc.Content)

      
        
        258
        +	_, _ = w.Write(fc.Content)

      
        259
        259
         }

      
        260
        260
         

      
        261
        261
         type RepoLog struct {

      
M internal/markdown/relink.go
路路路
        141
        141
         func (r *rawBlockRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {

      
        142
        142
         	reg.Register(rawBlockKind, func(w util.BufWriter, _ []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {

      
        143
        143
         		if entering {

      
        144
        
        -			w.Write(node.(*rawBlock).data)

      
        
        144
        +			_, _ = w.Write(node.(*rawBlock).data)

      
        145
        145
         		}

      
        146
        146
         		return ast.WalkContinue, nil

      
        147
        147
         	})

      
M internal/ssh/ssh.go
路路路
        74
        74
         	}

      
        75
        75
         

      
        76
        76
         	if s.cfg.Meta.Modt != "" {

      
        77
        
        -		fmt.Fprintln(stderr, s.cfg.Meta.Modt)

      
        
        77
        +		_, _ = fmt.Fprintln(stderr, s.cfg.Meta.Modt)

      
        78
        78
         	}

      
        79
        79
         

      
        80
        80
         	switch gitCmd {

      
M testscript_test.go
路路路
        36
        36
         		fmt.Fprintf(os.Stderr, "failed to create temp dir: %v\n", err)

      
        37
        37
         		return 1

      
        38
        38
         	}

      
        39
        
        -	defer os.RemoveAll(tmpDir)

      
        
        39
        +	defer func() { _ = os.RemoveAll(tmpDir) }()

      
        40
        40
         

      
        41
        41
         	reposDir = filepath.Join(tmpDir, "repos")

      
        42
        42
         	if jerr := os.MkdirAll(reposDir, 0o755); jerr != nil {

      路路路
        106
        106
         	}

      
        107
        107
         

      
        108
        108
         	code := m.Run()

      
        109
        
        -	httpServer.Shutdown(ctx)

      
        
        109
        +	_ = httpServer.Shutdown(ctx)

      
        110
        110
         	return code

      
        111
        111
         }

      
        112
        112
         

      路路路
        146
        146
         	cmd := exec.Command("go", "build", "-o", mugitBin, ".")

      
        147
        147
         	cmd.Dir = "."

      
        148
        148
         	if out, err := cmd.CombinedOutput(); err != nil {

      
        149
        
        -		os.RemoveAll(tmpDir)

      
        
        149
        +		_ = os.RemoveAll(tmpDir)

      
        150
        150
         		return fmt.Errorf("go build: %v\n%s", err, out)

      
        151
        151
         	}

      
        152
        152
         	return nil

      路路路
        158
        158
         		return 0, err

      
        159
        159
         	}

      
        160
        160
         	port := l.Addr().(*net.TCPAddr).Port

      
        161
        
        -	l.Close()

      
        
        161
        +	_ = l.Close()

      
        162
        162
         	return port, nil

      
        163
        163
         }

      
        164
        164
         

      路路路
        170
        170
         			net.JoinHostPort("127.0.0.1", strconv.Itoa(port)),

      
        171
        171
         			200*time.Millisecond,

      
        172
        172
         		); err == nil {

      
        173
        
        -			conn.Close()

      
        
        173
        +			_ = conn.Close()

      
        174
        174
         			return nil

      
        175
        175
         		}

      
        176
        176
         		time.Sleep(50 * time.Millisecond)