Upload instead of package

Author: kyleconroy

internal/bundler/build.go

@@ -1,70 +1,19 @@
 package bundler
 
 import (
-	"archive/tar"
-	"encoding/json"
-	"fmt"
 	"runtime"
 	"time"
 
 	"github.com/kyleconroy/sqlc/internal/info"
 )
 
-type jsonTime struct {
-	time.Time
-}
-
-func (t jsonTime) MarshalJSON() ([]byte, error) {
-	//do your serializing here
-	stamp := fmt.Sprintf("\"%s\"", t.Format(time.RFC3339))
-	return []byte(stamp), nil
-}
-
-type setting struct {
-	Key, Value string
-}
-
-type metadata struct {
-	Version   string    `json:"version"`
-	GoVersion string    `json:"go_version"`
-	GOOS      string    `json:"goos"`
-	GOARCH    string    `json:"goarch"`
-	Created   jsonTime  `json:"created"`
-	Settings  []setting `json:"settings"`
-}
-
-func buildMetadata() (*metadata, error) {
-	return &metadata{
-		Version:   info.Version,
-		GoVersion: runtime.Version(),
-		GOOS:      runtime.GOOS,
-		GOARCH:    runtime.GOARCH,
-		Created:   jsonTime{time.Now().UTC()},
+func projectMetadata() ([][2]string, error) {
+	now := time.Now().UTC()
+	return [][2]string{
+		{"sqlc_version", info.Version},
+		{"go_version", runtime.Version()},
+		{"goos", runtime.GOOS},
+		{"goach", runtime.GOARCH},
+		{"created", now.Format(time.RFC3339)},
 	}, nil
 }
-
-func addMetadata(w *tar.Writer) error {
-	md, err := buildMetadata()
-	if err != nil {
-		return err
-	}
-	blob, err := json.Marshal(md)
-	if err != nil {
-		return err
-	}
-	header := &tar.Header{
-		Name:       "metadata.json",
-		Size:       int64(len(blob)),
-		Mode:       0420,
-		ModTime:    md.Created.Time,
-		AccessTime: md.Created.Time,
-		ChangeTime: md.Created.Time,
-	}
-	if err := w.WriteHeader(header); err != nil {
-		return err
-	}
-	if _, err := w.Write(blob); err != nil {
-		return err
-	}
-	return nil
-}

internal/bundler/metadata.go

@@ -0,0 +1,62 @@
+package bundler
+
+import (
+	"io"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+
+	"github.com/kyleconroy/sqlc/internal/config"
+	"github.com/kyleconroy/sqlc/internal/sql/sqlpath"
+)
+
+func writeContents(w *multipart.Writer, file string, conf *config.Config) error {
+	refs := map[string]struct{}{}
+	refs[filepath.Base(file)] = struct{}{}
+
+	for _, pkg := range conf.SQL {
+		for _, paths := range []config.Paths{pkg.Schema, pkg.Queries} {
+			files, err := sqlpath.Glob(paths)
+			if err != nil {
+				return err
+			}
+			for _, file := range files {
+				refs[file] = struct{}{}
+			}
+		}
+	}
+
+	for file, _ := range refs {
+		if err := addPart(w, file); err != nil {
+			return err
+		}
+	}
+
+	params, err := projectMetadata()
+	if err != nil {
+		return err
+	}
+	for _, val := range params {
+		if err = w.WriteField(val[0], val[1]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func addPart(w *multipart.Writer, file string) error {
+	h, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+	defer h.Close()
+	part, err := w.CreateFormFile("contents", file)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(part, h)
+	if err != nil {
+		return err
+	}
+	return nil
+}

internal/bundler/multipart.go

@@ -0,0 +1,60 @@
+package bundler
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+
+	"github.com/kyleconroy/sqlc/internal/config"
+)
+
+type Uploader struct {
+	configPath string
+	config     *config.Config
+}
+
+func NewUploader(configPath string, conf *config.Config) *Uploader {
+	return &Uploader{
+		configPath: configPath,
+		config:     conf,
+	}
+}
+
+func (up *Uploader) Upload(ctx context.Context) error {
+	body := bytes.NewBuffer([]byte{})
+
+	gw := gzip.NewWriter(body)
+	defer gw.Close()
+	w := multipart.NewWriter(gw)
+	defer w.Close()
+
+	if err := writeContents(w, up.configPath, up.config); err != nil {
+		return err
+	}
+
+	if err := gw.Flush(); err != nil {
+		return err
+	}
+	w.Close()
+	gw.Close()
+
+	req, err := http.NewRequest("POST", "http://localhost:8000/upload", body)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", w.FormDataContentType())
+	req = req.WithContext(ctx)
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("code=%d", resp.StatusCode)
+	}
+	return nil
+}

internal/bundler/upload.go

@@ -1,7 +1,7 @@
 package cmd
 
 import (
-	"crypto/sha256"
+	"context"
 	"fmt"
 	"io"
 	"os"
@@ -12,39 +12,27 @@ import (
 )
 
 var packageCmd = &cobra.Command{
-	Use:   "build",
-	Short: "Create a tarball containing schema, queries, and configuration",
+	Use:   "upload",
+	Short: "Upload the schema, queries, and configuration for this project",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		stderr := cmd.ErrOrStderr()
 		dir, name := getConfigPath(stderr, cmd.Flag("file"))
-		if err := createPkg(ParseEnv(cmd), dir, name, stderr); err != nil {
-			fmt.Fprintf(stderr, "error building package: %s\n", err)
+		if err := createPkg(cmd.Context(), ParseEnv(cmd), dir, name, stderr); err != nil {
+			fmt.Fprintf(stderr, "error uploading project: %s\n", err)
 			os.Exit(1)
 		}
 		return nil
 	},
 }
 
-func createPkg(e Env, dir, filename string, stderr io.Writer) error {
+func createPkg(ctx context.Context, e Env, dir, filename string, stderr io.Writer) error {
 	configPath, conf, err := readConfig(stderr, dir, filename)
 	if err != nil {
 		return err
 	}
-	tarball, err := bundler.Build(configPath, conf)
+	up := bundler.NewUploader(configPath, conf)
 	if err != nil {
 		return err
 	}
-
-	// TODO: Move this to the configuration file
-	owner := "tabbed"
-	project := "sqlc"
-
-	checksum := sha256.Sum256(tarball)
-	sha := fmt.Sprintf("%x", checksum)
-	output := fmt.Sprintf("%s_%s_%s.tar.gz", owner, project, sha[:10])
-	if err := os.WriteFile(output, tarball, 0644); err != nil {
-		return err
-	}
-
-	return nil
+	return up.Upload(ctx)
 }