Add binaryservice

actions/admin.go

@@ -0,0 +1,89 @@
+package actions
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"gitea.benny.dog/torjus/ezshare/pb"
+	"github.com/urfave/cli/v2"
+	"google.golang.org/grpc"
+)
+
+func ParseBinary(path string) (*pb.Binary, error) {
+	baseName := filepath.Base(path)
+
+	pattern := `ezshare-(\d+\.\d+\.\d+).([a-z]+)-([a-z1-9]+)(\.exe)*`
+	re := regexp.MustCompile(pattern)
+
+	match := re.FindStringSubmatch(baseName)
+	if len(match) < 4 {
+		return nil, fmt.Errorf("invalid filename")
+	}
+	version := fmt.Sprintf("v%s", match[1])
+	operatingSystem := match[2]
+	arch := match[3]
+
+	binary := &pb.Binary{
+		Arch:    arch,
+		Os:      operatingSystem,
+		Version: version,
+	}
+
+	// TODO: Verify that os and arch are valid
+
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	binary.Data, err = io.ReadAll(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return binary, nil
+}
+
+func ActionAdminUploadBinary(c *cli.Context) error {
+	if c.Args().Len() < 1 {
+		return cli.Exit("need at least 1 argument", 1)
+	}
+	cfg, err := getConfig(c)
+	if err != nil {
+		return err
+	}
+
+	addr := cfg.Client.DefaultServer
+	if c.IsSet("addr") {
+		addr = c.String("addr")
+	}
+
+	clientCreds, err := cfg.Client.Creds()
+	if err != nil {
+		return err
+	}
+	conn, err := grpc.DialContext(c.Context, addr, grpc.WithTransportCredentials(clientCreds), grpc.WithMaxMsgSize(1024*1024*100))
+
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	client := pb.NewBinaryServiceClient(conn)
+
+	var binaries []*pb.Binary
+	for _, arg := range c.Args().Slice() {
+		binary, err := ParseBinary(arg)
+		if err != nil {
+			return cli.Exit(fmt.Sprintf("error reading binary: %s", err), 1)
+		}
+		binaries = append(binaries, binary)
+	}
+	if _, err := client.UploadBinaries(c.Context, &pb.UploadBinariesRequest{Binaries: binaries}); err != nil {
+		return cli.Exit(fmt.Sprintf("error upload binaries: %s", err), 1)
+	}
+	return nil
+}

actions/client.go

@@ -12,11 +12,13 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"runtime"
 	"syscall"
 	"time"
 
 	"gitea.benny.dog/torjus/ezshare/certs"
 	"gitea.benny.dog/torjus/ezshare/config"
+	"gitea.benny.dog/torjus/ezshare/ezshare"
 	"gitea.benny.dog/torjus/ezshare/pb"
 	"gitea.benny.dog/torjus/ezshare/server"
 	"github.com/urfave/cli/v2"
@@ -470,3 +472,66 @@ func ActionClientCertRevoke(c *cli.Context) error {
 	}
 	return nil
 }
+
+func ActionClientUpdate(c *cli.Context) error {
+	cfg, err := getConfig(c)
+	if err != nil {
+		return err
+	}
+
+	addr := cfg.Client.DefaultServer
+	if c.IsSet("addr") {
+		addr = c.String("addr")
+	}
+
+	clientCreds, err := cfg.Client.Creds()
+	if err != nil {
+		return err
+	}
+	conn, err := grpc.DialContext(c.Context, addr, grpc.WithTransportCredentials(clientCreds))
+
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	client := pb.NewBinaryServiceClient(conn)
+
+	// Check if we have the latest version
+	resp, err := client.GetLatestVersion(c.Context, &pb.Empty{})
+	if err != nil {
+		return cli.Exit(fmt.Sprintf("Error getting latest version: %s", err), 1)
+	}
+
+	if resp.Version == ezshare.Version {
+		fmt.Println("Already running latest version.")
+		return nil
+	}
+
+	// Fetch latest version
+	bin, err := client.GetBinary(c.Context, &pb.GetBinaryRequest{Version: "latest", Arch: runtime.GOARCH, Os: runtime.GOOS})
+	if err != nil {
+		return cli.Exit(fmt.Sprintf("Error getting binary: %s", err), 1)
+	}
+
+	outDir := "."
+	if c.IsSet("out-dir") {
+		outDir = c.String("out-dir")
+	}
+	filename := fmt.Sprintf("ezshare-%s-%s-%s", bin.Version[1:], bin.Os, bin.Arch)
+	if runtime.GOOS == "windows" {
+		filename = fmt.Sprintf("%s.exe", filename)
+	}
+	outputPath := filepath.Join(outDir, filename)
+
+	f, err := os.Create(outputPath)
+	if err != nil {
+		return cli.Exit(fmt.Sprintf("Unable to write latest binary: %s", err), 1)
+	}
+
+	if _, err := f.Write(bin.Data); err != nil {
+		return cli.Exit(fmt.Sprintf("Unable to write latest binary: %s", err), 1)
+	}
+	fmt.Printf("Wrote latest binary to %s", outputPath)
+	return nil
+}

actions/misc.go

@@ -8,6 +8,9 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
+// TODO: This should probably be in some more sensible package
+const Version = "v0.1.1"
+
 func ActionGencerts(c *cli.Context) error {
 	outDir := "."
 	if c.IsSet("out-dir") {

actions/serve.go

@@ -34,6 +34,7 @@ func ActionServe(c *cli.Context) error {
 	authLogger := logger.Named("AUTH")
 	httpLogger := logger.Named("HTTP")
 	certLogger := logger.Named("CERT")
+	binsLogger := logger.Named("BINS")
 
 	// Read certificates
 	srvCertBytes, err := cfg.Server.GRPC.Certs.GetCertBytes()
@@ -82,6 +83,9 @@ func ActionServe(c *cli.Context) error {
 		return fmt.Errorf("error initializing certificate service: %w", err)
 	}
 
+	// Setup binary store
+	binaryStore := store.NewMemoryStore()
+
 	// Setup shutdown-handling
 	rootCtx, rootCancel := signal.NotifyContext(context.Background(), os.Interrupt)
 	defer rootCancel()
@@ -117,6 +121,9 @@ func ActionServe(c *cli.Context) error {
 		grpcUserServer := server.NewGRPCUserServiceServer(userStore, certSvc)
 		grpcUserServer.Logger = logger.Named("USER")
 
+		binaryServer := server.NewBinaryServiceServer(binaryStore)
+		binaryServer.Logger = binsLogger
+
 		lis, err := net.Listen("tcp", grpcAddr)
 		if err != nil {
 			serverLogger.Errorw("Unable to setup GRPC listener.", "error", err)
@@ -140,12 +147,15 @@ func ActionServe(c *cli.Context) error {
 		creds := credentials.NewTLS(tlsConfig)
 
 		grpcServer := grpc.NewServer(
+			grpc.MaxRecvMsgSize(100*1024*1024),
+			grpc.MaxSendMsgSize(100*1024*1024),
 			grpc.Creds(creds),
 			grpc.ChainUnaryInterceptor(interceptors.NewAuthInterceptor(userStore, certSvc, authLogger)),
 		)
 		pb.RegisterFileServiceServer(grpcServer, grpcFileServer)
 		pb.RegisterUserServiceServer(grpcServer, grpcUserServer)
 		pb.RegisterCertificateServiceServer(grpcServer, certServiceServer)
+		pb.RegisterBinaryServiceServer(grpcServer, binaryServer)
 
 		// wait for cancel
 		go func() {