-e=deport-ass filename

src/asses/deport.go

@@ -14,6 +14,10 @@ import (
 	"strings"
 )
 
+func Entrypoint(ctx context.Context, p string) error {
+	return deport(ctx, p)
+}
+
 func deport(ctx context.Context, p string) error {
 	if os.Getenv("NO_DEPORT") != "" {
 		log.Printf("would deport %s", p)

src/cmd/config.go

@@ -10,8 +10,10 @@ import (
 )
 
 type Flags struct {
-	DB   string
+	DB         string
-	Port int
+	Port       int
+	Entrypoint Entrypoint
+	Pos        []string
 }
 
 func NewFlags(args []string) (Flags, error) {
@@ -19,26 +21,28 @@ func NewFlags(args []string) (Flags, error) {
 
 	fs := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
 	fs.StringVar(&result.DB, "db", "/tmp/f.db", "path to sqlite.db")
-	fs.IntVar(&result.Port, "p", 10_000, "port for http")
+	fs.IntVar(&result.Port, "p", 10000, "port for http")
+	fs.Var(&result.Entrypoint, "e", "entrypoint")
 	err := fs.Parse(args)
+	result.Pos = fs.Args()
 
 	return result, err
 }
 
-func Config(ctx context.Context, args []string) (context.Context, func(), error) {
+func Config(ctx context.Context, args []string) (context.Context, func(), Flags, error) {
 	flags, err := NewFlags(args)
 	if err != nil {
-		return ctx, nil, err
+		return ctx, nil, flags, err
 	}
 
 	ctx, err = db.Inject(ctx, flags.DB)
 	if err != nil {
-		return ctx, nil, err
+		return ctx, nil, flags, err
 	}
 
 	ctx = server.Inject(ctx, flags.Port)
 
 	return ctx, func() {
 		cleanup.Extract(ctx)()
-	}, nil
+	}, flags, nil
 }

src/cmd/main.go

@@ -4,10 +4,12 @@ import (
 	"context"
 	"fmt"
 	"log"
+	inass "show-rss/src/asses"
 	"show-rss/src/cmd/asses"
 	"show-rss/src/cmd/fetch"
 	"show-rss/src/cmd/server"
 	"show-rss/src/pool"
+	"strings"
 	"time"
 )
 
@@ -15,27 +17,72 @@ func Main(ctx context.Context, args []string) error {
 	ctx, can := context.WithCancel(ctx)
 	defer can()
 
-	ctx, can, err := Config(ctx, args)
+	ctx, can, flags, err := Config(ctx, args)
 	if err != nil {
 		return fmt.Errorf("failed to inject: %w", err)
 	}
 	defer can()
 
-	foos := map[string]func(context.Context) error{
+	switch flags.Entrypoint {
-		"server": server.Main,
+	case Defacto:
-		"fetch":  fetch.Main,
+		foos := map[string]func(context.Context) error{
-		"asses":  asses.Main,
+			"server": server.Main,
-	}
+			"fetch":  fetch.Main,
-	p := pool.New(len(foos))
+			"asses":  asses.Main,
-	defer p.Wait(ctx)
-
-	for k, foo := range foos {
-		if err := p.Go(ctx, k, runner(ctx, k, foo)); err != nil {
-			return fmt.Errorf("failed to go %s: %v", k, err)
 		}
-	}
+		p := pool.New(len(foos))
+		defer p.Wait(ctx)
 
-	return p.Wait(ctx)
+		for k, foo := range foos {
+			if err := p.Go(ctx, k, runner(ctx, k, foo)); err != nil {
+				return fmt.Errorf("failed to go %s: %v", k, err)
+			}
+		}
+
+		return p.Wait(ctx)
+	case DeportAss:
+		for _, pos := range flags.Pos {
+			if err := inass.Entrypoint(ctx, pos); err != nil {
+				return err
+			}
+		}
+		return nil
+	default:
+		panic(flags.Entrypoint.String())
+	}
+	return nil
+}
+
+type Entrypoint int
+
+const (
+	Defacto Entrypoint = iota
+	DeportAss
+)
+
+func (e *Entrypoint) Set(s string) error {
+	switch s {
+	case Defacto.String():
+		*e = Defacto
+	case DeportAss.String():
+		*e = DeportAss
+	default:
+		return fmt.Errorf("%s nin (%s)", s, strings.Join([]string{
+			Defacto.String(),
+			DeportAss.String(),
+		}, ", "))
+	}
+	return nil
+}
+
+func (e Entrypoint) String() string {
+	switch e {
+	case Defacto:
+		return ""
+	case DeportAss:
+		return "deport-ass"
+	}
+	panic("cannot serialize entrypoint")
 }
 
 func runner(ctx context.Context, k string, foo func(context.Context) error) func() error {