main.go

package main

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"os"

	"github.com/go-git/go-git/v5/plumbing"
	"github.com/go-git/go-git/v5/plumbing/protocol/packp"
	"github.com/go-git/go-git/v5/plumbing/protocol/packp/capability"
	"github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband"
	"github.com/go-git/go-git/v5/plumbing/transport"
	"github.com/go-git/go-git/v5/plumbing/transport/client"
	"github.com/go-git/go-git/v5/storage/memory"
)

func main() {
	ctx := context.Background()

	if err := mainImpl(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}

type todoType interface{ Nothing() }

func mainImpl(ctx context.Context) error {
	from := os.Args[1]
	to := os.Args[2]

	up, err := startUploadPack(from, nil)
	if err != nil {
		return fmt.Errorf("error starting upload-pack: %w", err)
	}
	defer checkClose(up, "upload-pack")

	originAdv, err := up.GetAdvertisement(ctx)
	if err != nil {
		return fmt.Errorf("%s: error getting ref advertisement: %w", from, err)
	}
	originRefs, err := originAdv.AllReferences()
	if err != nil {
		return fmt.Errorf("%s: error reading advertised refs: %w", from, err)
	}
	//remoteRefs, err := ar.AllReferences()
	//req := packp.NewUploadPackRequestFromCapabilities(ar.Capabilities)
	//req, err := r.newUploadPackRequest(o, ar)

	rp, err := startReceivePack(to, nil)
	if err != nil {
		return fmt.Errorf("%s: error starting receive-pack: %w", to, err)
	}
	defer checkClose(rp, "receive-pack")

	destAdv, err := rp.GetAdvertisement(ctx)
	if err != nil {
		return fmt.Errorf("%s: error getting ref advertisement: %w", to, err)
	}
	destRefs, err := destAdv.AllReferences()
	if err != nil {
		return fmt.Errorf("%s: error reading advertised refs: %w", to, err)
	}

	f, updates, err := compareRefs(originRefs, destRefs)
	if err != nil {
		return fmt.Errorf("error comparing refs: %w", err)
	}
	fmt.Printf("%d haves, %d wants, %d updates ...\n", len(f.haves), len(f.wants), len(updates))
	if len(updates) == 0 {
		return nil
	}

	packReader, err := up.GetPack(ctx, originAdv, f)
	if err != nil {
		return fmt.Errorf("error getting pack data: %w", err)
	}
	//defer checkClose(packReader, "upload-pack data")

	if os.Getenv("DEBUG_PACK") != "" && packReader != nil {
		dbg, err := os.Create(os.Getenv("DEBUG_PACK"))
		if err != nil {
			return fmt.Errorf("debug.pack: %w", err)
		}
		defer checkClose(dbg, "debug.pack")
		packReader = &rc{io.TeeReader(packReader, dbg), packReader}
	}

	if err := rp.SendPack(ctx, destAdv, updates, packReader); err != nil {
		return fmt.Errorf("error sending pack data: %w", err)
	}

	fmt.Printf("Success! Mirrored from %s to %s\n", from, to)
	return nil
}

type rc struct {
	r io.Reader
	c io.Closer
}

func (d *rc) Read(p []byte) (n int, err error) { return d.r.Read(p) }
func (d *rc) Close() error                     { return d.c.Close() }

func compareRefs(fromRefs, toRefs memory.ReferenceStorage) (fetchHashes, []*packp.Command, error) {
	// haves = all oids in toRefs.
	// wants = all oids in fromRefs that aren't in toRefs.
	// updates = all differences between fromRefs and toRefs.
	var haves, wants []plumbing.Hash
	var updates []*packp.Command

	toRefIter, err := toRefs.IterReferences()
	if err != nil {
		return fetchHashes{}, nil, fmt.Errorf("error creating ref iterator: %w", err)
	}

	knownOIDs := make(map[plumbing.Hash]struct{})
	if err := toRefIter.ForEach(func(ref *plumbing.Reference) error {
		if ref.Type() != plumbing.HashReference {
			return nil
		}

		knownOIDs[ref.Hash()] = struct{}{}

		if r, err := fromRefs.Reference(ref.Name()); err != nil {
			updates = append(updates, &packp.Command{
				Name: ref.Name(),
				Old:  ref.Hash(),
				New:  plumbing.ZeroHash,
			})
		} else if r.Hash() != ref.Hash() {
			updates = append(updates, &packp.Command{
				Name: ref.Name(),
				Old:  ref.Hash(),
				New:  r.Hash(),
			})
		}

		return nil
	}); err != nil {
		return fetchHashes{}, nil, fmt.Errorf("error generating commands for new refs: %w", err)
	}

	haves = make([]plumbing.Hash, 0, len(knownOIDs))
	for k := range knownOIDs {
		haves = append(haves, k)
	}

	fromRefIter, err := fromRefs.IterReferences()
	if err != nil {
		return fetchHashes{}, nil, fmt.Errorf("error creating ref iterator: %w", err)
	}

	if err := fromRefIter.ForEach(func(ref *plumbing.Reference) error {
		if ref.Type() != plumbing.HashReference {
			return nil
		}

		if _, ok := knownOIDs[ref.Hash()]; !ok {
			wants = append(wants, ref.Hash())
		}

		if _, err := toRefs.Reference(ref.Name()); err == plumbing.ErrReferenceNotFound {
			updates = append(updates, &packp.Command{
				Name: ref.Name(),
				Old:  plumbing.ZeroHash,
				New:  ref.Hash(),
			})
		}

		return nil
	}); err != nil {
		return fetchHashes{}, nil, fmt.Errorf("error generating commands for new refs: %w", err)
	}

	return fetchHashes{
		haves: haves,
		wants: wants,
	}, updates, nil
}

func startUploadPack(url string, auth transport.AuthMethod) (*uploadPackHelper, error) {
	c, ep, err := newClient(url)
	if err != nil {
		return nil, fmt.Errorf("error creating client: %w", err)
	}

	s, err := c.NewUploadPackSession(ep, auth)
	if err != nil {
		return nil, fmt.Errorf("error creating session: %w", err)
	}

	return &uploadPackHelper{s, c, ep}, nil
}

func startReceivePack(url string, auth transport.AuthMethod) (*receivePackHelper, error) {
	c, ep, err := newClient(url)
	if err != nil {
		return nil, fmt.Errorf("error creating client: %w", err)
	}

	s, err := c.NewReceivePackSession(ep, auth)
	if err != nil {
		return nil, fmt.Errorf("error creating session: %w", err)
	}

	return &receivePackHelper{s, c, ep}, nil
}

func newClient(url string) (transport.Transport, *transport.Endpoint, error) {
	ep, err := transport.NewEndpoint(url)
	if err != nil {
		return nil, nil, fmt.Errorf("%s: %w", url, err)
	}

	c, err := client.NewClient(ep)
	if err != nil {
		return nil, nil, fmt.Errorf("error creating client for %s: %w", url, err)
	}

	return c, ep, nil
}

type uploadPackHelper struct {
	s  transport.UploadPackSession
	c  transport.Transport
	ep *transport.Endpoint
}

func (h *uploadPackHelper) Close() error {
	return h.s.Close()
}

func (h *uploadPackHelper) GetAdvertisement(ctx context.Context) (*packp.AdvRefs, error) {
	return h.s.AdvertisedReferencesContext(ctx)
}

func (h *uploadPackHelper) GetPack(ctx context.Context, ar *packp.AdvRefs, f fetchHashes) (io.ReadCloser, error) {
	req := packp.NewUploadPackRequestFromCapabilities(ar.Capabilities)
	req.Wants = f.wants
	req.Haves = f.haves
	resp, err := h.s.UploadPack(ctx, req)
	if err != nil {
		if errors.Is(err, transport.ErrEmptyUploadPackRequest) {
			return io.NopCloser(bytes.NewReader([]byte{
				'P', 'A', 'C', 'K',
				0, 0, 0, 2,
				0, 0, 0, 0,
				0x02, 0x9d, 0x08, 0x82,
				0x3b, 0xd8, 0xa8, 0xea,
				0xb5, 0x10, 0xad, 0x6a,
				0xc7, 0x5c, 0x82, 0x3c,
				0xfd, 0x3e, 0xd3, 0x1e,
			})), nil
		}
		return nil, err
	}

	return handleSideband(resp, ar.Capabilities), nil
}

func handleSideband(r io.ReadCloser, caps *capability.List) io.ReadCloser {
	if caps.Supports(capability.Sideband64k) {
		d := sideband.NewDemuxer(sideband.Sideband64k, r)
		d.Progress = os.Stderr
		return &rc{d, r}
	}
	if caps.Supports(capability.Sideband) {
		d := sideband.NewDemuxer(sideband.Sideband, r)
		d.Progress = os.Stderr
		return &rc{d, r}
	}
	return r
}

type fetchHashes struct {
	haves, wants []plumbing.Hash
}

type receivePackHelper struct {
	s  transport.ReceivePackSession
	c  transport.Transport
	ep *transport.Endpoint
}

func (h *receivePackHelper) Close() error {
	return h.s.Close()
}

func (h *receivePackHelper) GetAdvertisement(ctx context.Context) (*packp.AdvRefs, error) {
	return h.s.AdvertisedReferencesContext(ctx)
}

func (h *receivePackHelper) SendPack(ctx context.Context, ar *packp.AdvRefs, updates []*packp.Command, packData io.ReadCloser) error {
	req := packp.NewReferenceUpdateRequestFromCapabilities(ar.Capabilities)
	req.Progress = os.Stderr
	// req.Progress = ...
	// if ar.Capabilities.Supports(capability.Sideband64k) {
	// 	_ = req.Capabilities.Set(capability.Sideband64k)
	// } else if ar.Capabilities.Supports(capability.Sideband) {
	// 	_ = req.Capabilities.Set(capability.Sideband)
	// }
	req.Commands = updates
	req.Packfile = packData
	st, err := h.s.ReceivePack(ctx, req)
	if err != nil {
		return fmt.Errorf("receive-pack: %w", err)
	}
	fmt.Printf("objects: %v\n", st.UnpackStatus)
	okRefs := 0
	for _, cs := range st.CommandStatuses {
		if cs.Status == "ok" {
			okRefs++
		} else {
			fmt.Printf("%s: %v\n", cs.ReferenceName, cs.Status)
		}
	}
	if okRefs > 0 {
		fmt.Printf("ok refs: %d\n", okRefs)
	}
	return nil
}

func checkClose(c io.Closer, label string) {
	if err := c.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "%s: error closing: %v\n", label, err)
	}
}