commit 502e31e751a1c7d9564fba95e1c5d3177fa188a1 · hailey.at/myaur

+27 -8

cmd/myaur/main.go

···

       6
       6
        
       	"log"

     

       7
       7
        
       	"os"

     

       8
       8
        
       

     

       9
       9
       +
       	"github.com/haileyok/myaur/myaur/gitrepo"

     

       9
       10
        
       	"github.com/haileyok/myaur/myaur/populate"

     

       10
       11
        
       	"github.com/haileyok/myaur/myaur/server"

     

       11
       12
        
       	"github.com/urfave/cli/v2"

     
···

       29
       30
        
       						Usage: "path to store/update the AUR git mirror",

     

       30
       31
        
       						Value: "./aur-mirror",

     

       31
       32
        
       					},

     

       33
       33
       +
       					&cli.StringFlag{

     

       34
       34
       +
       						Name:  "remote-repo-url",

     

       35
       35
       +
       						Usage: "remote aur repo url",

     

       36
       36
       +
       						Value: gitrepo.DefaultAurRepoUrl,

     

       37
       37
       +
       					},

     

       32
       38
        
       					&cli.BoolFlag{

     

       33
       39
        
       						Name:  "debug",

     

       34
       40
        
       						Usage: "flag to enable debug logs",

     
···

       43
       49
        
       					ctx := context.Background()

     

       44
       50
        
       

     

       45
       51
        
       					p, err := populate.New(&populate.Args{

     

       46
       46
       -
       						DatabasePath: cmd.String("database-path"),

     

       47
       47
       -
       						RepoPath:     cmd.String("repo-path"),

     

       48
       48
       -
       						Debug:        cmd.Bool("debug"),

     

       49
       49
       -
       						Concurrency:  cmd.Int("concurrency"),

     

       52
       52
       +
       						DatabasePath:  cmd.String("database-path"),

     

       53
       53
       +
       						RepoPath:      cmd.String("repo-path"),

     

       54
       54
       +
       						RemoteRepoUrl: cmd.String("remote-repo-url"),

     

       55
       55
       +
       						Debug:         cmd.Bool("debug"),

     

       56
       56
       +
       						Concurrency:   cmd.Int("concurrency"),

     

       50
       57
        
       					})

     

       51
       58
        
       					if err != nil {

     

       52
       59
        
       						return fmt.Errorf("failed to create populate client: %w", err)

     
···

       77
       84
        
       						Usage: "path to database file",

     

       78
       85
        
       						Value: "./myaur.db",

     

       79
       86
        
       					},

     

       87
       87
       +
       					&cli.StringFlag{

     

       88
       88
       +
       						Name:  "remote-repo-url",

     

       89
       89
       +
       						Usage: "remote aur repo url",

     

       90
       90
       +
       						Value: gitrepo.DefaultAurRepoUrl,

     

       91
       91
       +
       					},

     

       92
       92
       +
       					&cli.StringFlag{

     

       93
       93
       +
       						Name:  "repo-path",

     

       94
       94
       +
       						Usage: "path to store/update the AUR git mirror",

     

       95
       95
       +
       						Value: "./aur-mirror",

     

       96
       96
       +
       					},

     

       80
       97
        
       					&cli.BoolFlag{

     

       81
       98
        
       						Name:  "debug",

     

       82
       99
        
       						Usage: "flag to enable debug logs",

     
···

       86
       103
        
       					ctx := context.Background()

     

       87
       104
        
       

     

       88
       105
        
       					s, err := server.New(&server.Args{

     

       89
       89
       -
       						Addr:         cmd.String("listen-addr"),

     

       90
       90
       -
       						MetricsAddr:  cmd.String("metrics-listen-addr"),

     

       91
       91
       -
       						DatabasePath: cmd.String("database-path"),

     

       92
       92
       -
       						Debug:        cmd.Bool("debug"),

     

       106
       106
       +
       						Addr:          cmd.String("listen-addr"),

     

       107
       107
       +
       						MetricsAddr:   cmd.String("metrics-listen-addr"),

     

       108
       108
       +
       						DatabasePath:  cmd.String("database-path"),

     

       109
       109
       +
       						RemoteRepoUrl: cmd.String("remote-repo-url"),

     

       110
       110
       +
       						RepoPath:      cmd.String("repo-path"),

     

       111
       111
       +
       						Debug:         cmd.Bool("debug"),

     

       93
       112
        
       					})

     

       94
       113
        
       					if err != nil {

     

       95
       114
        
       						return fmt.Errorf("failed to create new myaur server: %w", err)

go.mod

···

       5
       5
        
       require (

     

       6
       6
        
       	github.com/labstack/echo/v4 v4.13.4

     

       7
       7
        
       	github.com/labstack/gommon v0.4.2

     

       8
       8
       +
       	github.com/samber/slog-echo v1.18.0

     

       8
       9
        
       	github.com/urfave/cli/v2 v2.27.7

     

       9
       10
        
       	golang.org/x/sync v0.14.0

     

       10
       11
        
       	gorm.io/driver/sqlite v1.6.0

     
···

       19
       20
        
       	github.com/mattn/go-isatty v0.0.20 // indirect

     

       20
       21
        
       	github.com/mattn/go-sqlite3 v1.14.22 // indirect

     

       21
       22
        
       	github.com/russross/blackfriday/v2 v2.1.0 // indirect

     

       23
       23
       +
       	github.com/samber/lo v1.51.0 // indirect

     

       22
       24
        
       	github.com/valyala/bytebufferpool v1.0.0 // indirect

     

       23
       25
        
       	github.com/valyala/fasttemplate v1.2.2 // indirect

     

       24
       26
        
       	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect

     

       27
       27
       +
       	go.opentelemetry.io/otel v1.29.0 // indirect

     

       28
       28
       +
       	go.opentelemetry.io/otel/trace v1.29.0 // indirect

     

       25
       29
        
       	golang.org/x/crypto v0.38.0 // indirect

     

       26
       30
        
       	golang.org/x/net v0.40.0 // indirect

     

       27
       31
        
       	golang.org/x/sys v0.33.0 // indirect

     

       28
       32
        
       	golang.org/x/text v0.25.0 // indirect

     

       33
       33
       +
       	golang.org/x/time v0.11.0 // indirect

     

       29
       34
        
       )

+12

go.sum

···

       2
       2
        
       github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=

     

       3
       3
        
       github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       4
       4
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       5
       5
       +
       github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

     

       6
       6
       +
       github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

     

       5
       7
        
       github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=

     

       6
       8
        
       github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=

     

       7
       9
        
       github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=

     
···

       20
       22
        
       github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       21
       23
        
       github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=

     

       22
       24
        
       github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

     

       25
       25
       +
       github.com/samber/lo v1.51.0 h1:kysRYLbHy/MB7kQZf5DSN50JHmMsNEdeY24VzJFu7wI=

     

       26
       26
       +
       github.com/samber/lo v1.51.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=

     

       27
       27
       +
       github.com/samber/slog-echo v1.18.0 h1:fnDeUhwqoAsQZxbmIizO0avwE0qjjoefAvhXoByxN3U=

     

       28
       28
       +
       github.com/samber/slog-echo v1.18.0/go.mod h1:4diugqPTk6iQdL7gZFJIyf6zGMLVMaGnCmNm+DBSMRU=

     

       23
       29
        
       github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=

     

       24
       30
        
       github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       25
       31
        
       github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU=

     
···

       30
       36
        
       github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=

     

       31
       37
        
       github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=

     

       32
       38
        
       github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=

     

       39
       39
       +
       go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw=

     

       40
       40
       +
       go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8=

     

       41
       41
       +
       go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4=

     

       42
       42
       +
       go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ=

     

       33
       43
        
       golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=

     

       34
       44
        
       golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=

     

       35
       45
        
       golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=

     
···

       41
       51
        
       golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

     

       42
       52
        
       golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=

     

       43
       53
        
       golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=

     

       54
       54
       +
       golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=

     

       55
       55
       +
       golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=

     

       44
       56
        
       gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       45
       57
        
       gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       46
       58
        
       gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ=

myaur/database/database.go

···

       98
       98
        
       	}

     

       99
       99
        
       	return pkgs, nil

     

       100
       100
        
       }

     

       101
       101
       +
       

     

       102
       102
       +
       func (db *Database) GetPackagesByNames(names []string) ([]PackageInfo, error) {

     

       103
       103
       +
       	var pkgs []PackageInfo

     

       104
       104
       +
       	if err := db.db.Where("name IN ?", names).Find(&pkgs).Error; err != nil {

     

       105
       105
       +
       		return nil, err

     

       106
       106
       +
       	}

     

       107
       107
       +
       	return pkgs, nil

     

       108
       108
       +
       }

+9 -4

myaur/database/models.go

···

       21
       21
        
       		return nil

     

       22
       22
        
       	}

     

       23
       23
        
       

     

       24
       24
       -
       	bytes, ok := value.([]byte)

     

       25
       25
       -
       	if !ok {

     

       26
       26
       -
       		return fmt.Errorf("failed to unmarshal StringSlice value: %v", value)

     

       24
       24
       +
       	var bytes []byte

     

       25
       25
       +
       	switch v := value.(type) {

     

       26
       26
       +
       	case []byte:

     

       27
       27
       +
       		bytes = v

     

       28
       28
       +
       	case string:

     

       29
       29
       +
       		bytes = []byte(v)

     

       30
       30
       +
       	default:

     

       31
       31
       +
       		return fmt.Errorf("failed to unmarshal StringSlice value: %v (type: %T)", value, value)

     

       27
       32
        
       	}

     

       28
       33
        
       

     

       29
       34
        
       	return json.Unmarshal(bytes, s)

     
···

       32
       37
        
       type PackageInfo struct {

     

       33
       38
        
       	Id             int64       `gorm:"primaryKey;autoIncrement" json:"ID"`

     

       34
       39
        
       	Name           string      `gorm:"uniqueIndex;not null" json:"Name"`

     

       35
       35
       -
       	PackageBaseID  string      `json:"PackageBaseID"`

     

       40
       40
       +
       	PackageBaseID  int64       `json:"PackageBaseID"`

     

       36
       41
        
       	PackageBase    string      `gorm:"index" json:"PackageBase"`

     

       37
       42
        
       	Version        string      `json:"Version"`

     

       38
       43
        
       	Description    string      `gorm:"index:idx_description" json:"Description"`

+8 -6

myaur/populate/populate.go

···

       22
       22
        
       }

     

       23
       23
        
       

     

       24
       24
        
       type Args struct {

     

       25
       25
       -
       	DatabasePath string

     

       26
       26
       -
       	RepoPath     string

     

       27
       27
       -
       	Debug        bool

     

       28
       28
       -
       	Concurrency  int

     

       25
       25
       +
       	DatabasePath  string

     

       26
       26
       +
       	RepoPath      string

     

       27
       27
       +
       	RemoteRepoUrl string

     

       28
       28
       +
       	Debug         bool

     

       29
       29
       +
       	Concurrency   int

     

       29
       30
        
       }

     

       30
       31
        
       

     

       31
       32
        
       func New(args *Args) (*Populate, error) {

     
···

       46
       47
        
       	}

     

       47
       48
        
       

     

       48
       49
        
       	repo, err := gitrepo.New(&gitrepo.Args{

     

       49
       49
       -
       		RepoPath: args.RepoPath,

     

       50
       50
       -
       		Debug:    args.Debug,

     

       50
       50
       +
       		RepoPath:   args.RepoPath,

     

       51
       51
       +
       		AurRepoUrl: args.RemoteRepoUrl,

     

       52
       52
       +
       		Debug:      args.Debug,

     

       51
       53
        
       	})

     

       52
       54
        
       	if err != nil {

     

       53
       55
        
       		return nil, fmt.Errorf("failed to create repo client: %w", err)

+29 -1

myaur/server/handle_get_info.go

···

       2
       2
        
       

     

       3
       3
        
       import "github.com/labstack/echo/v4"

     

       4
       4
        
       

     

       5
       5
       +
       type GetInfoInput struct {

     

       6
       6
       +
       	Arg []string `query:"arg"`

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       5
       9
        
       func (s *Server) handleGetInfo(e echo.Context) error {

     

       6
       6
       -
       	return nil

     

       10
       10
       +
       	logger := s.logger.With("route", "getInfo")

     

       11
       11
       +
       

     

       12
       12
       +
       	// HACK: probably better way to do this...

     

       13
       13
       +
       	queryParams := e.QueryParams()

     

       14
       14
       +
       	args := queryParams["arg[]"]

     

       15
       15
       +
       	if len(args) == 0 {

     

       16
       16
       +
       		args = queryParams["arg"]

     

       17
       17
       +
       	}

     

       18
       18
       +
       

     

       19
       19
       +
       	if len(args) == 0 {

     

       20
       20
       +
       		return e.JSON(400, makeErrJson("Missing `arg` parameter"))

     

       21
       21
       +
       	}

     

       22
       22
       +
       

     

       23
       23
       +
       	pkgs, err := s.db.GetPackagesByNames(args)

     

       24
       24
       +
       	if err != nil {

     

       25
       25
       +
       		logger.Error("failed to lookup packages", "err", err)

     

       26
       26
       +
       		return e.JSON(500, makeErrJson("Failed to search for packages"))

     

       27
       27
       +
       	}

     

       28
       28
       +
       

     

       29
       29
       +
       	return e.JSON(200, GetSearchOutput{

     

       30
       30
       +
       		Version:     5,

     

       31
       31
       +
       		Type:        "search",

     

       32
       32
       +
       		ResultCount: len(pkgs),

     

       33
       33
       +
       		Results:     pkgs,

     

       34
       34
       +
       	})

     

       7
       35
        
       }

+44

myaur/server/handle_get_rpc.go

···

       1
       1
       +
       package server

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"net/http"

     

       5
       5
       +
       

     

       6
       6
       +
       	"github.com/labstack/echo/v4"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func (s *Server) handleRpc(e echo.Context) error {

     

       10
       10
       +
       	queryParams := e.QueryParams()

     

       11
       11
       +
       	rpcType := e.QueryParam("type")

     

       12
       12
       +
       	version := e.QueryParam("v")

     

       13
       13
       +
       

     

       14
       14
       +
       	if version == "" {

     

       15
       15
       +
       		version = "5"

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	// HACK: there's probably a better way to do this with echo...

     

       19
       19
       +
       	args := queryParams["arg[]"]

     

       20
       20
       +
       	if len(args) == 0 {

     

       21
       21
       +
       		args = queryParams["arg"]

     

       22
       22
       +
       	}

     

       23
       23
       +
       

     

       24
       24
       +
       	switch rpcType {

     

       25
       25
       +
       	case "search":

     

       26
       26
       +
       		// there will be a single arg in search, since it does a `like` match

     

       27
       27
       +
       		if len(args) == 0 {

     

       28
       28
       +
       			return e.JSON(http.StatusBadRequest, makeErrJson("Missing `arg` parameter"))

     

       29
       29
       +
       		}

     

       30
       30
       +
       		e.SetPath("/rpc/v5/search/:term")

     

       31
       31
       +
       		e.SetParamNames("term")

     

       32
       32
       +
       		e.SetParamValues(args[0])

     

       33
       33
       +
       		return s.handleGetSearch(e)

     

       34
       34
       +
       	case "info", "query":

     

       35
       35
       +
       		// there whould be an array, i.e. arg[]=discord-canary&arg[]=slack

     

       36
       36
       +
       		if len(args) == 0 {

     

       37
       37
       +
       			return e.JSON(http.StatusBadRequest, makeErrJson("Missing `arg` parameter"))

     

       38
       38
       +
       		}

     

       39
       39
       +
       		e.SetPath("/rpc/v5/info")

     

       40
       40
       +
       		return s.handleGetInfo(e)

     

       41
       41
       +
       	default:

     

       42
       42
       +
       		return e.JSON(http.StatusBadRequest, makeErrJson("Missing or invalid `type` parameter"))

     

       43
       43
       +
       	}

     

       44
       44
       +
       }

+11 -13

myaur/server/handle_get_search.go

···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"strings"

     

       5
       5
       -
       

     

       6
       4
        
       	"github.com/haileyok/myaur/myaur/database"

     

       7
       5
        
       	"github.com/labstack/echo/v4"

     

       8
       6
        
       )

     
···

       29
       27
        
       	ResultCount int                    `json:"resultcount"`

     

       30
       28
        
       	Results     []database.PackageInfo `json:"results"`

     

       31
       29
        
       	Error       *string                `json:"error,omitempty"`

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       func makeErrJson(error string) GetSearchOutput {

     

       33
       33
       +
       	return GetSearchOutput{

     

       34
       34
       +
       		Version:     5,

     

       35
       35
       +
       		Type:        "error",

     

       36
       36
       +
       		ResultCount: 0,

     

       37
       37
       +
       		Results:     []database.PackageInfo{},

     

       38
       38
       +
       		Error:       &error,

     

       39
       39
       +
       	}

     

       32
       40
        
       }

     

       33
       41
        
       

     

       34
       42
        
       // Depending on what the `by` parameter is, should receive one of the following as path:

     
···

       40
       48
        
       // `optdepends`: search for packages that optdepends on a keyword

     

       41
       49
        
       // `checkdepends`: search for packages that checkdepends on a keyword

     

       42
       50
        
       func (s *Server) handleGetSearch(e echo.Context) error {

     

       43
       43
       -
       	makeErrJson := func(error string) GetSearchOutput {

     

       44
       44
       -
       		return GetSearchOutput{

     

       45
       45
       -
       			Version:     5,

     

       46
       46
       -
       			Type:        "error",

     

       47
       47
       -
       			ResultCount: 0,

     

       48
       48
       -
       			Results:     []database.PackageInfo{},

     

       49
       49
       -
       			Error:       &error,

     

       50
       50
       -
       		}

     

       51
       51
       -
       	}

     

       52
       51
        
       	logger := s.logger.With("handler", "getSearch")

     

       53
       52
        
       

     

       54
       53
        
       	var input GetSearchInput

     
···

       68
       67
        
       		input.By = "name"

     

       69
       68
        
       	}

     

       70
       69
        
       

     

       71
       71
       -
       	termPts := strings.Split(e.Request().URL.Path, "/")

     

       72
       72
       -
       	term := termPts[len(termPts)-1]

     

       70
       70
       +
       	term := e.Param("term")

     

       73
       71
        
       

     

       74
       72
        
       	var pkgs []database.PackageInfo

     

       75
       73
        
       	var err error

+136

myaur/server/handle_git.go

···

       1
       1
       +
       package server

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"bytes"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"io"

     

       7
       7
       +
       	"os/exec"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       

     

       10
       10
       +
       	"github.com/labstack/echo/v4"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func (s *Server) handleGit(e echo.Context) error {

     

       14
       14
       +
       	if s.repoPath == "" {

     

       15
       15
       +
       		return e.String(503, "Git operations require local mirror")

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	// strip off any leading slash from the path

     

       19
       19
       +
       	path := e.Request().URL.Path

     

       20
       20
       +
       	if after, ok := strings.CutPrefix(path, "/"); ok {

     

       21
       21
       +
       		path = after

     

       22
       22
       +
       	}

     

       23
       23
       +
       

     

       24
       24
       +
       	// get the name and git path from the url path

     

       25
       25
       +
       	pts := strings.SplitN(path, "/", 2)

     

       26
       26
       +
       	if len(pts) == 0 {

     

       27
       27
       +
       		return e.String(404, "Not Found")

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	packageName := strings.TrimSuffix(pts[0], ".git")

     

       31
       31
       +
       

     

       32
       32
       +
       	var gitPath string

     

       33
       33
       +
       	if len(pts) > 1 {

     

       34
       34
       +
       		gitPath = pts[1]

     

       35
       35
       +
       	}

     

       36
       36
       +
       

     

       37
       37
       +
       	// return a symref pointing to master for head requests

     

       38
       38
       +
       	if gitPath == "HEAD" {

     

       39
       39
       +
       		e.Response().Header().Set("Content-Type", "text/plain")

     

       40
       40
       +
       		return e.String(200, "ref: refs/heads/master\n")

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	// handle info/refs request

     

       44
       44
       +
       	if gitPath == "info/refs" && strings.Contains(e.Request().URL.RawQuery, "service=git-upload-pack") {

     

       45
       45
       +
       		return s.serveInfoRefs(e, packageName)

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	// handle git-upload-pack request

     

       49
       49
       +
       	if gitPath == "git-upload-pack" {

     

       50
       50
       +
       		return s.serveUploadPack(e, packageName)

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	return e.String(404, "Not Found")

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       func (s *Server) serveInfoRefs(e echo.Context, packageName string) error {

     

       57
       57
       +
       	logger := s.logger.With("route", "handleGit", "git-component", "serveInfoRefs", "package-name", packageName)

     

       58
       58
       +
       

     

       59
       59
       +
       	cmd := exec.Command("git", "-C", s.repoPath, "show-ref", fmt.Sprintf("refs/heads/%s", packageName))

     

       60
       60
       +
       	output, err := cmd.Output()

     

       61
       61
       +
       	if err != nil {

     

       62
       62
       +
       		logger.Error("branch not found", "err", err)

     

       63
       63
       +
       		return e.String(404, "Package not found")

     

       64
       64
       +
       	}

     

       65
       65
       +
       

     

       66
       66
       +
       	refLine := strings.TrimSpace(string(output))

     

       67
       67
       +
       	refParts := strings.Fields(refLine)

     

       68
       68
       +
       	if len(refParts) != 2 {

     

       69
       69
       +
       		logger.Error("invalid ref format", "output", refLine)

     

       70
       70
       +
       		return e.String(500, "Invalid ref format")

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	commitHash := refParts[0]

     

       74
       74
       +
       

     

       75
       75
       +
       	// WARNING: SLOP CODE

     

       76
       76
       +
       	// claude apparently knows how to create these smart HTPP responses for git. it works on my machine,

     

       77
       77
       +
       	// but...lol

     

       78
       78
       +
       	var buf bytes.Buffer

     

       79
       79
       +
       

     

       80
       80
       +
       	// Write packet: service announcement

     

       81
       81
       +
       	service := "# service=git-upload-pack\n"

     

       82
       82
       +
       	buf.WriteString(fmt.Sprintf("%04x%s", len(service)+4, service))

     

       83
       83
       +
       	buf.WriteString("0000") // flush packet

     

       84
       84
       +
       

     

       85
       85
       +
       	// Advertise HEAD and master branch

     

       86
       86
       +
       	// Format: hash + SP + ref + NULL + capabilities + LF

     

       87
       87
       +
       	// NOTE: these were the ones claude kept adding until yay didn't yell at me anymore. not sure if they are all needed though

     

       88
       88
       +
       	capabilities := "multi_ack multi_ack_detailed thin-pack side-band side-band-64k ofs-delta shallow no-progress include-tag symref=HEAD:refs/heads/master"

     

       89
       89
       +
       

     

       90
       90
       +
       	// Advertise HEAD first with symref capability

     

       91
       91
       +
       	headRef := fmt.Sprintf("%s HEAD\x00%s\n", commitHash, capabilities)

     

       92
       92
       +
       	buf.WriteString(fmt.Sprintf("%04x%s", len(headRef)+4, headRef))

     

       93
       93
       +
       

     

       94
       94
       +
       	// because aur usually has a single repo for each package, but we have a single repo with individual

     

       95
       95
       +
       	// branches for each package, we need to spoof this to show that the ref is refs/heads/master

     

       96
       96
       +
       	masterRef := fmt.Sprintf("%s refs/heads/master\n", commitHash)

     

       97
       97
       +
       	buf.WriteString(fmt.Sprintf("%04x%s", len(masterRef)+4, masterRef))

     

       98
       98
       +
       

     

       99
       99
       +
       	// claude says this is the flush packet

     

       100
       100
       +
       	buf.WriteString("0000")

     

       101
       101
       +
       

     

       102
       102
       +
       	e.Response().Header().Set("Content-Type", "application/x-git-upload-pack-advertisement")

     

       103
       103
       +
       	e.Response().Header().Set("Cache-Control", "no-cache")

     

       104
       104
       +
       	return e.Blob(200, "application/x-git-upload-pack-advertisement", buf.Bytes())

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       func (s *Server) serveUploadPack(e echo.Context, packageName string) error {

     

       108
       108
       +
       	logger := s.logger.With("route", "handleGit", "git-component", "serveUploadPack", "package-name", packageName)

     

       109
       109
       +
       

     

       110
       110
       +
       	bodyBytes, err := io.ReadAll(e.Request().Body)

     

       111
       111
       +
       	if err != nil {

     

       112
       112
       +
       		logger.Error("failed to read upload-pack request", "err", err)

     

       113
       113
       +
       		return e.String(400, "Failed to read request")

     

       114
       114
       +
       	}

     

       115
       115
       +
       

     

       116
       116
       +
       	// because aur usually has a single repo for each package, but we have a single repo with individual

     

       117
       117
       +
       	// branches for each package, we need to spoof this to show that the ref is refs/heads/master

     

       118
       118
       +
       	modifiedBody := bytes.ReplaceAll(bodyBytes, []byte("refs/heads/master"), fmt.Appendf(nil, "refs/heads/%s", packageName))

     

       119
       119
       +
       

     

       120
       120
       +
       	// then we can use upload-pack to serve the pack file

     

       121
       121
       +
       	cmd := exec.Command("git", "upload-pack", "--stateless-rpc", s.repoPath)

     

       122
       122
       +
       	cmd.Stdin = bytes.NewReader(modifiedBody)

     

       123
       123
       +
       

     

       124
       124
       +
       	var stdout, stderr bytes.Buffer

     

       125
       125
       +
       	cmd.Stdout = &stdout

     

       126
       126
       +
       	cmd.Stderr = &stderr

     

       127
       127
       +
       

     

       128
       128
       +
       	if err := cmd.Run(); err != nil {

     

       129
       129
       +
       		logger.Error("upload-pack failed", "err", err, "stderr", stderr.String(), "package", packageName)

     

       130
       130
       +
       		return e.String(500, fmt.Sprintf("upload pack failed: %s", stderr.String()))

     

       131
       131
       +
       	}

     

       132
       132
       +
       

     

       133
       133
       +
       	e.Response().Header().Set("Content-Type", "application/x-git-upload-pack-result")

     

       134
       134
       +
       	e.Response().Header().Set("Cache-Control", "no-cache")

     

       135
       135
       +
       	return e.Blob(200, "application/x-git-upload-pack-result", stdout.Bytes())

     

       136
       136
       +
       }

+35 -24

myaur/server/server.go

···

       11
       11
        
       	"time"

     

       12
       12
        
       

     

       13
       13
        
       	"github.com/haileyok/myaur/myaur/database"

     

       14
       14
       +
       	"github.com/haileyok/myaur/myaur/gitrepo"

     

       14
       15
        
       	"github.com/labstack/echo/v4"

     

       16
       16
       +
       	"github.com/labstack/echo/v4/middleware"

     

       15
       17
        
       	"github.com/labstack/gommon/log"

     

       18
       18
       +
       	slogecho "github.com/samber/slog-echo"

     

       16
       19
        
       )

     

       17
       20
        
       

     

       18
       21
        
       type Server struct {

     

       19
       19
       -
       	logger       *slog.Logger

     

       20
       20
       -
       	echo         *echo.Echo

     

       21
       21
       -
       	httpd        *http.Server

     

       22
       22
       -
       	metricsHttpd *http.Server

     

       23
       23
       -
       	db           *database.Database

     

       22
       22
       +
       	logger        *slog.Logger

     

       23
       23
       +
       	echo          *echo.Echo

     

       24
       24
       +
       	httpd         *http.Server

     

       25
       25
       +
       	metricsHttpd  *http.Server

     

       26
       26
       +
       	db            *database.Database

     

       27
       27
       +
       	remoteRepoUrl string

     

       28
       28
       +
       	repoPath      string

     

       24
       29
        
       }

     

       25
       30
        
       

     

       26
       31
        
       type Args struct {

     

       27
       27
       -
       	Addr         string

     

       28
       28
       -
       	MetricsAddr  string

     

       29
       29
       -
       	DatabasePath string

     

       30
       30
       -
       	Debug        bool

     

       32
       32
       +
       	Addr          string

     

       33
       33
       +
       	MetricsAddr   string

     

       34
       34
       +
       	DatabasePath  string

     

       35
       35
       +
       	RemoteRepoUrl string

     

       36
       36
       +
       	RepoPath      string

     

       37
       37
       +
       	Debug         bool

     

       31
       38
        
       }

     

       32
       39
        
       

     

       33
       40
        
       func New(args *Args) (*Server, error) {

     
···

       36
       43
        
       		level = slog.LevelDebug

     

       37
       44
        
       	}

     

       38
       45
        
       

     

       46
       46
       +
       	if args.RemoteRepoUrl == "" {

     

       47
       47
       +
       		args.RemoteRepoUrl = gitrepo.DefaultAurRepoUrl

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       39
       50
        
       	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{

     

       40
       51
        
       		Level: level,

     

       41
       52
        
       	}))

     

       42
       53
        
       

     

       43
       54
        
       	e := echo.New()

     

       55
       55
       +
       

     

       56
       56
       +
       	e.Use(middleware.Recover())

     

       57
       57
       +
       	e.Use(slogecho.New(logger))

     

       44
       58
        
       

     

       45
       59
        
       	httpd := http.Server{

     

       46
       60
        
       		Addr:    args.Addr,

     
···

       60
       74
        
       	}

     

       61
       75
        
       

     

       62
       76
        
       	s := Server{

     

       63
       63
       -
       		echo:         e,

     

       64
       64
       -
       		httpd:        &httpd,

     

       65
       65
       -
       		metricsHttpd: &metricsHttpd,

     

       66
       66
       -
       		db:           db,

     

       67
       67
       -
       		logger:       logger,

     

       77
       77
       +
       		echo:          e,

     

       78
       78
       +
       		httpd:         &httpd,

     

       79
       79
       +
       		metricsHttpd:  &metricsHttpd,

     

       80
       80
       +
       		db:            db,

     

       81
       81
       +
       		logger:        logger,

     

       82
       82
       +
       		remoteRepoUrl: args.RemoteRepoUrl,

     

       83
       83
       +
       		repoPath:      args.RepoPath,

     

       68
       84
        
       	}

     

       69
       85
        
       

     

       70
       86
        
       	return &s, nil

     
···

       148
       164
        
       }

     

       149
       165
        
       

     

       150
       166
        
       func (s *Server) addRoutes() {

     

       167
       167
       +
       	s.echo.GET("/rpc", s.handleRpc)

     

       151
       168
        
       	s.echo.GET("/rpc/v5/info", s.handleGetInfo)

     

       152
       152
       -
       	s.echo.GET("/rpc/v5/search", s.handleGetSearch)

     

       153
       153
       -
       }

     

       169
       169
       +
       	s.echo.GET("/rpc/v5/search/:term", s.handleGetSearch)

     

       154
       170
        
       

     

       155
       155
       -
       func makeErrorJson(error string, message string) map[string]string {

     

       156
       156
       -
       	jsonMap := map[string]string{

     

       157
       157
       -
       		"error": error,

     

       158
       158
       -
       	}

     

       159
       159
       -
       	if message != "" {

     

       160
       160
       -
       		jsonMap["message"] = message

     

       161
       161
       -
       	}

     

       162
       162
       -
       	return jsonMap

     

       171
       171
       +
       	// git will make both get and post requests

     

       172
       172
       +
       	s.echo.GET("/*", s.handleGit)

     

       173
       173
       +
       	s.echo.POST("/*", s.handleGit)

     

       163
       174
        
       }