Merge pull request #33 from hathora/post-release-bugfixes

Post release bugfixes

.github/workflows/ci.yaml

@@ -130,12 +130,13 @@ jobs:
           TARGETOS: ${{ matrix.os }}
           TARGETARCH: ${{ matrix.arch }}
           BUILD_VERSION: ${{ needs.prepare.outputs.version }}
+          BINARY_SUFFIX: ${{ matrix.os == 'windows' && '.exe' || '' }}
         run: make build
 
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: hathora-${{ matrix.os }}-${{ matrix.arch }}
+          name: hathora-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.os == 'windows' && '.exe' || '' }}
           path: bin/hathora-*
 
   release:

Dockerfile

@@ -8,7 +8,7 @@ RUN go mod download
 
 # copy source
 COPY Makefile Makefile
-COPY cmd cmd
+COPY hathora.go hathora.go
 COPY internal internal
 
 ARG TARGETOS

Makefile

@@ -6,6 +6,7 @@ SHELL = /usr/bin/env bash -o pipefail
 TARGETOS ?= darwin
 TARGETARCH ?= arm64
 BUILD_VERSION ?= $(shell git describe --always --dirty)
+BINARY_SUFFIX ?= ""
 
 .PHONY: all
 all: build
@@ -19,9 +20,9 @@ clean: ## Delete all built binaries.
 build: ## Build the command binaries.
 	CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} \
     go build \
-        -o bin/hathora-${TARGETOS}-${TARGETARCH} \
+        -o bin/hathora-${TARGETOS}-${TARGETARCH}${BINARY_SUFFIX} \
         -ldflags "-X 'github.com/hathora/ci/internal/commands.BuildVersion=${BUILD_VERSION}'" \
-        cmd/run.go
+        hathora.go
 
 .PHONY: sdk-clean
 sdk-clean: ## Re-generate the SDK using speakeasyapi.dev

README.md

@@ -13,7 +13,7 @@ For documentation on how to use this CLI, check out our [docs.](https://hathora.
 To run the CLI locally, execute the following:
 
 ```sh
-go run cmd/main.go --help
+go run hathora.go --help
 ```
 
 ### Running tests
@@ -38,6 +38,14 @@ The target OS and architecture can be specified by setting the `OS` and `ARCH` e
 TARGETOS=linux TARGETARCH=amd64 make build
 ```
 
+> [!NOTE]
+> When building on windows you'll want the built binaries to include the `.exe` suffix. To achieve this, you can use the `BINARY_SUFFIX`
+> variable, e.g.:
+>
+> ```sh
+> TARGETOS=windows TARGETARCH=amd64 BINARY_SUFFIX=.exe make build
+> ```
+
 The binary will be available in the `bin` directory.
 
 ```sh

internal/archive/targz.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strings"
 
 	"github.com/h2non/filetype"
 	"github.com/monochromegane/go-gitignore"
@@ -47,9 +48,9 @@ func shouldIgnoreFilepath(filepath string, isDir bool, matchers []gitignore.Igno
 	return anyMatches
 }
 
-func CreateTGZ(srcFolder string) (string, error) {
+func CreateTGZ(srcFolder string, ext string) (string, error) {
 	fileName := filepath.Base(filepath.Clean(srcFolder))
-	destinationFile := fmt.Sprintf("%s.*.tgz", fileName)
+	destinationFile := fmt.Sprintf("%s.*.%s", fileName, ext)
 	tarGzFile, err := os.CreateTemp("", destinationFile)
 	if err != nil {
 		return "", err
@@ -76,6 +77,10 @@ func CreateTGZ(srcFolder string) (string, error) {
 			return err
 		}
 
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
 		relPath, err := filepath.Rel(srcFolder, filePath)
 		if err != nil {
 			return err
@@ -115,7 +120,7 @@ func CreateTGZ(srcFolder string) (string, error) {
 			return fmt.Errorf("expected to write %d bytes but wrote %d bytes for file %s", info.Size(), written, filePath)
 		}
 
-		zap.L().Debug("Inlcluding file: " + relPath)
+		zap.L().Debug("Including file: " + relPath)
 		return nil
 	})
 
@@ -151,17 +156,30 @@ func isTGZ(filePath string) (bool, error) {
 		return false, fmt.Errorf("could not read file: %s", filePath)
 	}
 
-	if filetype.IsArchive(buff) {
-		fileExt := filepath.Ext(filePath)
-		if !slices.Contains(supportedFileExtensions, fileExt) {
-			err := fmt.Errorf("unsupported archive file extension: %s", fileExt)
-			return false, err
+	if !filetype.IsArchive(buff) {
+		return false, nil
+	}
+
+	var fileExtParts []string
+	for {
+		ext := filepath.Ext(filePath)
+		if ext == "" {
+			break
 		}
+		fileExtParts = append(fileExtParts, ext)
+		filePath = filePath[:len(filePath)-len(ext)]
+	}
+	slices.Reverse(fileExtParts)
 
-		return true, nil
+	var fileExt string
+	for i := 0; i < len(fileExtParts); i++ {
+		fileExt = strings.Join(fileExtParts[i:], "")
+		if slices.Contains(supportedFileExtensions, fileExt) {
+			return true, nil
+		}
 	}
 
-	return false, nil
+	return false, fmt.Errorf("unsupported archive file extension: %s", fileExt)
 }
 
 func RequireTGZ(srcFolder string) (*TGZFile, error) {
@@ -187,7 +205,7 @@ func RequireTGZ(srcFolder string) (*TGZFile, error) {
 
 	zap.L().Debug(srcFolder + " is not a gzipped tar archive. Archiving and compressing now.")
 
-	destFile, err := CreateTGZ(srcFolder)
+	destFile, err := CreateTGZ(srcFolder, "tgz")
 	if err != nil {
 		return nil, err
 	}

internal/archive/targz_test.go

@@ -86,7 +86,7 @@ func Test_CreateTGZ(t *testing.T) {
 				}
 			}
 
-			archivePath, err := archive.CreateTGZ(srcFolder)
+			archivePath, err := archive.CreateTGZ(srcFolder, "tgz")
 			if tt.shouldFail {
 				assert.Error(err)
 				return
@@ -137,3 +137,77 @@ func Test_CreateTGZ(t *testing.T) {
 		})
 	}
 }
+
+func Test_RequireTGZ(t *testing.T) {
+	zapLogger, _ := zap.NewDevelopment()
+	zap.ReplaceGlobals(zapLogger)
+	tests := []struct {
+		name             string
+		files            map[string]string
+		archiveExt       string
+		precreateArchive bool
+	}{
+		{
+			name: "existing .tgz",
+			files: map[string]string{
+				"file1.txt": "This is file 1",
+			},
+			archiveExt:       "tgz",
+			precreateArchive: true,
+		},
+		{
+			name: "existing .tar.gz",
+			files: map[string]string{
+				"file1.txt": "This is file 1",
+			},
+			archiveExt:       "tar.gz",
+			precreateArchive: true,
+		},
+		{
+			name: "existing .tar.tgz",
+			files: map[string]string{
+				"file1.txt": "This is file 1",
+			},
+			archiveExt:       "tar.tgz",
+			precreateArchive: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			srcFolder, err := os.MkdirTemp("", "testsrc")
+			require.NoError(t, err)
+			t.Cleanup(func() {
+				os.RemoveAll(srcFolder)
+			})
+
+			for path, content := range tt.files {
+				fullPath := filepath.Join(srcFolder, path)
+				if strings.HasSuffix(path, "/") {
+					require.NoError(t, os.MkdirAll(fullPath, os.ModePerm))
+				} else {
+					err := os.MkdirAll(filepath.Dir(fullPath), os.ModePerm)
+					require.NoError(t, err)
+					err = os.WriteFile(fullPath, []byte(content), 0644)
+					require.NoError(t, err)
+				}
+			}
+
+			var archivePath string
+			if tt.precreateArchive {
+				archivePath, err = archive.CreateTGZ(srcFolder, tt.archiveExt)
+				require.NoError(t, err)
+				t.Cleanup(func() {
+					os.Remove(archivePath)
+				})
+			}
+
+			tgzFile, err := archive.RequireTGZ(archivePath)
+			require.NoError(t, err)
+			require.NotNil(t, tgzFile)
+			assert.Equal(archivePath, tgzFile.Path)
+		})
+	}
+}

internal/commands/common.go

@@ -194,13 +194,12 @@ func BuildTextFormatter() output.FormatWriter {
 			"RequestedMemoryMB",
 			"DefaultContainerPort",
 			"AdditionalContainerPorts",
-			"Env",
 		),
 		output.RenameField(deployment, "RequestedMemoryMB", "RequestedMemory"),
 		output.WithPropertyFormatter(deployment, "RequestedMemoryMB", func(f float64) string {
 			return humanize.IBytes((uint64)(f * 1024 * 1024))
 		}),
-		output.WithoutFields(deployment, "AppID", "CreatedBy"),
+		output.WithoutFields(deployment, "AppID", "CreatedBy", "Env"),
 		output.WithFormatter(envVar,
 			func(e shared.DeploymentV2Env) string {
 				return fmt.Sprintf("%s=%s", e.Name, e.Value)

internal/output/text_test.go

@@ -52,8 +52,8 @@ func Test_DeploymentTextOutput(t *testing.T) {
 				RequestedCPU:      0.5,
 			},
 			expect: [][]string{
-				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts", "Env"},
-				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp", "EULA=TRUE"},
+				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts"},
+				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp"},
 			},
 		},
 		{
@@ -88,8 +88,8 @@ func Test_DeploymentTextOutput(t *testing.T) {
 				RequestedCPU:      0.5,
 			},
 			expect: [][]string{
-				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts", "Env"},
-				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp", "EULA=TRUE"},
+				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts"},
+				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp"},
 			},
 		},
 		{
@@ -155,9 +155,9 @@ func Test_DeploymentTextOutput(t *testing.T) {
 				},
 			},
 			expect: [][]string{
-				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts", "Env"},
-				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp", "EULA=TRUE"},
-				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp", "EULA=TRUE"},
+				{"DeploymentID", "BuildID", "CreatedAt", "IdleTimeoutEnabled", "RoomsPerProcess", "RequestedCPU", "RequestedMemory", "DefaultContainerPort", "AdditionalContainerPorts"},
+				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp"},
+				{"2", "1", "2021-01-01T00:00:00Z", "true", "3", "0.5", "1.0", "GiB", "default:3000/tcp", "debug:4000/tcp"},
 			},
 		},
 	}