Skip to content

Logging Part 1: initial trace2 events (start, cmd_name, error, exit, atexit) #28

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 10 commits into from
Feb 27, 2023
30 changes: 20 additions & 10 deletions cmd/git-bundle-server/delete.go
Original file line number Diff line number Diff line change
@@ -1,47 +1,57 @@
package main

import (
"context"
"os"

"github.com/github/git-bundle-server/internal/argparse"
"github.com/github/git-bundle-server/internal/core"
"github.com/github/git-bundle-server/internal/log"
)

type Delete struct{}
type deleteCmd struct {
logger log.TraceLogger
}

func NewDeleteCommand(logger log.TraceLogger) argparse.Subcommand {
return &deleteCmd{
logger: logger,
}
}

func (Delete) Name() string {
func (deleteCmd) Name() string {
return "delete"
}

func (Delete) Description() string {
func (deleteCmd) Description() string {
return `
Remove the configuration for the given '<route>' and delete its repository
data.`
}

func (Delete) Run(args []string) error {
parser := argparse.NewArgParser("git-bundle-server delete <route>")
func (d *deleteCmd) Run(ctx context.Context, args []string) error {
parser := argparse.NewArgParser(d.logger, "git-bundle-server delete <route>")
route := parser.PositionalString("route", "the route to delete")
parser.Parse(args)
parser.Parse(ctx, args)

repo, err := core.CreateRepository(*route)
if err != nil {
return err
return d.logger.Error(ctx, err)
}

err = core.RemoveRoute(*route)
if err != nil {
return err
return d.logger.Error(ctx, err)
}

err = os.RemoveAll(repo.WebDir)
if err != nil {
return err
return d.logger.Error(ctx, err)
}

err = os.RemoveAll(repo.RepoDir)
if err != nil {
return err
return d.logger.Error(ctx, err)
}

return nil
36 changes: 23 additions & 13 deletions cmd/git-bundle-server/init.go
Original file line number Diff line number Diff line change
@@ -1,70 +1,80 @@
package main

import (
"context"
"fmt"

"github.com/github/git-bundle-server/internal/argparse"
"github.com/github/git-bundle-server/internal/bundles"
"github.com/github/git-bundle-server/internal/core"
"github.com/github/git-bundle-server/internal/git"
"github.com/github/git-bundle-server/internal/log"
)

type Init struct{}
type initCmd struct {
logger log.TraceLogger
}

func NewInitCommand(logger log.TraceLogger) argparse.Subcommand {
return &initCmd{
logger: logger,
}
}

func (Init) Name() string {
func (initCmd) Name() string {
return "init"
}

func (Init) Description() string {
func (initCmd) Description() string {
return `
Initialize a repository by cloning a bare repo from '<url>', whose bundles
should be hosted at '<route>'.`
}

func (Init) Run(args []string) error {
parser := argparse.NewArgParser("git-bundle-server init <url> <route>")
func (i *initCmd) Run(ctx context.Context, args []string) error {
parser := argparse.NewArgParser(i.logger, "git-bundle-server init <url> <route>")
url := parser.PositionalString("url", "the URL of a repository to clone")
// TODO: allow parsing <route> out of <url>
route := parser.PositionalString("route", "the route to host the specified repo")
parser.Parse(args)
parser.Parse(ctx, args)

repo, err := core.CreateRepository(*route)
if err != nil {
return err
return i.logger.Error(ctx, err)
}

fmt.Printf("Cloning repository from %s\n", *url)
gitErr := git.GitCommand("clone", "--bare", *url, repo.RepoDir)

if gitErr != nil {
return fmt.Errorf("failed to clone repository: %w", gitErr)
return i.logger.Errorf(ctx, "failed to clone repository: %w", gitErr)
}

gitErr = git.GitCommand("-C", repo.RepoDir, "config", "remote.origin.fetch", "+refs/heads/*:refs/heads/*")
if gitErr != nil {
return fmt.Errorf("failed to configure refspec: %w", gitErr)
return i.logger.Errorf(ctx, "failed to configure refspec: %w", gitErr)
}

gitErr = git.GitCommand("-C", repo.RepoDir, "fetch", "origin")
if gitErr != nil {
return fmt.Errorf("failed to fetch latest refs: %w", gitErr)
return i.logger.Errorf(ctx, "failed to fetch latest refs: %w", gitErr)
}

bundle := bundles.CreateInitialBundle(repo)
fmt.Printf("Constructing base bundle file at %s\n", bundle.Filename)

written, gitErr := git.CreateBundle(repo.RepoDir, bundle.Filename)
if gitErr != nil {
return fmt.Errorf("failed to create bundle: %w", gitErr)
return i.logger.Errorf(ctx, "failed to create bundle: %w", gitErr)
}
if !written {
return fmt.Errorf("refused to write empty bundle. Is the repo empty?")
return i.logger.Errorf(ctx, "refused to write empty bundle. Is the repo empty?")
}

list := bundles.CreateSingletonList(bundle)
listErr := bundles.WriteBundleList(list, repo)
if listErr != nil {
return fmt.Errorf("failed to write bundle list: %w", listErr)
return i.logger.Errorf(ctx, "failed to write bundle list: %w", listErr)
}

SetCronSchedule()
43 changes: 23 additions & 20 deletions cmd/git-bundle-server/main.go
Original file line number Diff line number Diff line change
@@ -1,36 +1,39 @@
package main

import (
"log"
"context"
"os"

"github.com/github/git-bundle-server/internal/argparse"
"github.com/github/git-bundle-server/internal/log"
)

func all() []argparse.Subcommand {
func all(logger log.TraceLogger) []argparse.Subcommand {
return []argparse.Subcommand{
Delete{},
Init{},
Start{},
Stop{},
Update{},
UpdateAll{},
NewWebServerCommand(),
NewDeleteCommand(logger),
NewInitCommand(logger),
NewStartCommand(logger),
NewStopCommand(logger),
NewUpdateCommand(logger),
NewUpdateAllCommand(logger),
NewWebServerCommand(logger),
}
}

func main() {
cmds := all()
log.WithTraceLogger(context.Background(), func(ctx context.Context, logger log.TraceLogger) {
cmds := all(logger)

parser := argparse.NewArgParser("git-bundle-server <command> [<options>]")
parser.SetIsTopLevel(true)
for _, cmd := range cmds {
parser.Subcommand(cmd)
}
parser.Parse(os.Args[1:])
parser := argparse.NewArgParser(logger, "git-bundle-server <command> [<options>]")
parser.SetIsTopLevel(true)
for _, cmd := range cmds {
parser.Subcommand(cmd)
}
parser.Parse(ctx, os.Args[1:])

err := parser.InvokeSubcommand()
if err != nil {
log.Fatal("Failed with error: ", err)
}
err := parser.InvokeSubcommand(ctx)
if err != nil {
logger.Fatalf(ctx, "Failed with error: %s", err)
}
})
}
27 changes: 18 additions & 9 deletions cmd/git-bundle-server/start.go
Original file line number Diff line number Diff line change
@@ -1,39 +1,48 @@
package main

import (
"fmt"
"context"
"os"

"github.com/github/git-bundle-server/internal/argparse"
"github.com/github/git-bundle-server/internal/core"
"github.com/github/git-bundle-server/internal/log"
)

type Start struct{}
type startCmd struct {
logger log.TraceLogger
}

func NewStartCommand(logger log.TraceLogger) argparse.Subcommand {
return &startCmd{
logger: logger,
}
}

func (Start) Name() string {
func (startCmd) Name() string {
return "start"
}

func (Start) Description() string {
func (startCmd) Description() string {
return `
Start computing bundles and serving content for the repository at the
specified '<route>'.`
}

func (Start) Run(args []string) error {
parser := argparse.NewArgParser("git-bundle-server start <route>")
func (s *startCmd) Run(ctx context.Context, args []string) error {
parser := argparse.NewArgParser(s.logger, "git-bundle-server start <route>")
route := parser.PositionalString("route", "the route for which bundles should be generated")
parser.Parse(args)
parser.Parse(ctx, args)

// CreateRepository registers the route.
repo, err := core.CreateRepository(*route)
if err != nil {
return err
return s.logger.Error(ctx, err)
}

_, err = os.ReadDir(repo.RepoDir)
if err != nil {
return fmt.Errorf("route '%s' appears to have been deleted; use 'init' instead", *route)
return s.logger.Errorf(ctx, "route '%s' appears to have been deleted; use 'init' instead", *route)
}

// Make sure we have the global schedule running.
30 changes: 23 additions & 7 deletions cmd/git-bundle-server/stop.go
Original file line number Diff line number Diff line change
@@ -1,26 +1,42 @@
package main

import (
"context"

"github.com/github/git-bundle-server/internal/argparse"
"github.com/github/git-bundle-server/internal/core"
"github.com/github/git-bundle-server/internal/log"
)

type Stop struct{}
type stopCmd struct {
logger log.TraceLogger
}

func (Stop) Name() string {
func NewStopCommand(logger log.TraceLogger) argparse.Subcommand {
return &stopCmd{
logger: logger,
}
}

func (stopCmd) Name() string {
return "stop"
}

func (Stop) Description() string {
func (stopCmd) Description() string {
return `
Stop computing bundles or serving content for the repository at the
specified '<route>'.`
}

func (Stop) Run(args []string) error {
parser := argparse.NewArgParser("git-bundle-server stop <route>")
func (s *stopCmd) Run(ctx context.Context, args []string) error {
parser := argparse.NewArgParser(s.logger, "git-bundle-server stop <route>")
route := parser.PositionalString("route", "the route for which bundles should stop being generated")
parser.Parse(args)
parser.Parse(ctx, args)

err := core.RemoveRoute(*route)
if err != nil {
s.logger.Error(ctx, err)
}

return core.RemoveRoute(*route)
return nil
}
Loading