Refactor the gate.AutoRegister API and hide the portal pb.go files

This should probably be several commits but it's too much and I don't
feel like splitting it up.

  1. Hid the protos from the public go API. This will enable me to drop
     gRPC or maybe even protos entirely without changing the go API
     again. Another reason for this is there are now two different
     output styles protoc can do for go code and this will allow me to
     update as proto styles update without breaking my API. This also
     lets me have nice things like tls.Config in the structs and uint16
     for port numbers (which protos don't support). So there's also
     wrapper functions for all the RPCs now.
  2. gate.AutoRegister no longer returns an annoying results struct.
     Also client.AutoRegisterChan is now just client.AutoRegister and it
     takes a callback function instead of a channel to write to (it's a
     more flexible API, you don't have to have goroutines just to split
     channels etc).
  3. tools.HTTPServer now takes a context not a quit channel
  4. Dropped tools.AutoTLSConf for now because I'm still debating what
     the right API for it should be. I want to have something like that
     still but I'm going to keep it private until I like the API better.
  5. Using crypto.PrivateKey instead of crypto.Signer now because it's
     more semantically correct

Most of this I actually wrote months ago. I decided back then I want to
try harder to have no dependencies and chose to move towards dropping
gRPC and this was my solution. Back then I inevitably lost momentum and
left myself with a difficult list of problems about how to import the
private protos across binaries and what to do about using prototext as
the public config file API for assimilate and spawn as well as the
gRPC/proto public API of the portal server. I also keep going back and
forth on the best API for AutoRegister (I don't love the one that spawns
a background goroutine still).

I suppose I'm moving towards using context instead of quit chans in all
the public APIs. I do think it's more friendly and idiomatic. I used to
kind of want to rebel against having ctx be the first arg of everything.

Recently I only fixed up the compile errors and got it ready to actually
commit.

Author: fsmv

assimilate/embedassimilate/assimilate.go

@@ -19,6 +19,7 @@ import (
 	_ "ask.systems/daemon/portal/flags"
 	_ "ask.systems/daemon/tools/flags"
 
+	"ask.systems/daemon/internal/portalpb"
 	"ask.systems/daemon/portal/gate"
 	"ask.systems/daemon/tools"
 	"google.golang.org/protobuf/encoding/prototext"
@@ -59,7 +60,7 @@ func Run(ctx context.Context, flags *flag.FlagSet, args []string) {
 	ctx, _ = tools.ContextWithQuitSignals(context.Background())
 	errCount := 0
 	for i, requestText := range flags.Args() {
-		registration := &gate.RegisterRequest{}
+		registration := &portalpb.RegisterRequest{}
 		err := prototext.Unmarshal([]byte(requestText), registration)
 		if err != nil {
 			log.Printf("Failed to unmarshal RegisterRequest #%v %#v: %v",
@@ -70,7 +71,13 @@ func Run(ctx context.Context, flags *flag.FlagSet, args []string) {
 		idx := i
 		wg.Add(1)
 		go func() {
-			err := client.AutoRegisterChan(ctx, registration, nil)
+			err := client.AutoRegister(ctx, &gate.RegisterRequest{
+				Pattern:      registration.Pattern,
+				FixedPort:    uint16(registration.FixedPort),
+				Hostname:     registration.Hostname,
+				StripPattern: registration.StripPattern,
+				AllowHttp:    registration.AllowHttp,
+			}, nil)
 			wg.Done()
 			if err != nil && !errors.Is(err, context.Cause(ctx)) {
 				log.Printf("Error for registration #%v: %v", idx, err)

host/embedhost/host.go

@@ -96,17 +96,16 @@ func Run(ctx context.Context, flags *flag.FlagSet, args []string) {
 
 	// Register the reverse proxy pattern with portal.
 	// Only blocks until the initial registration is done, then keeps renewing.
-	reg, waitForUnregister, err := gate.AutoRegister(ctx, &gate.RegisterRequest{
+	port, tlsconf, wait, err := gate.AutoRegister(ctx, &gate.RegisterRequest{
 		Pattern: *urlPath,
 	})
 	if err != nil {
 		log.Print("Fatal error registering with portal:", err)
 		return
 	}
 	// Start serving files (blocks until graceful stop is done)
-	tools.HTTPServer(ctx.Done(), reg.Lease.Port, reg.TLSConfig, nil)
-	// Wait for the AutoRegister background goroutine to gracefully stop
-	<-waitForUnregister
+	tools.HTTPServer(ctx, port, tlsconf, nil)
+	<-wait // Wait for the AutoRegister background goroutine to gracefully stop
 	log.Print("Goodbye.")
 }
 

internal/portalpb/embed.go

@@ -0,0 +1,6 @@
+package portalpb
+
+import _ "embed"
+
+//go:embed service.proto
+var ServiceProto string