Fix PHP version detection before Docker image building

.github/workflows/all-docker-images.yaml

@@ -14,7 +14,7 @@ on:
         description: Python SDK ver to build. Skipped if not specified. Must start with v.
         type: string
       php-ver:
-        description: PHP SDK ver to build. Skipped if not specified.
+        description: PHP SDK ver to build. Skipped if not specified. Must start with v.
         type: string
       ts-ver:
         description: TypeScript SDK ver to build. Skipped if not specified. Must start with v.

.github/workflows/ci.yaml

@@ -16,6 +16,9 @@ on: # rebuild any PRs and main branch changes
       java_sdk_version:
         default: ''
         type: string
+      php_sdk_version:
+        default: ''
+        type: string
       python_sdk_version:
         default: ''
         type: string
@@ -39,6 +42,7 @@ jobs:
       go_latest: ${{ steps.latest_version.outputs.go_latest }}
       typescript_latest: ${{ steps.latest_version.outputs.typescript_latest }}
       java_latest: ${{ steps.latest_version.outputs.java_latest }}
+      php_latest: ${{ steps.latest_version.outputs.php_latest }}
       python_latest: ${{ steps.latest_version.outputs.python_latest }}
       csharp_latest: ${{ steps.latest_version.outputs.csharp_latest }}
     steps:
@@ -75,6 +79,13 @@ jobs:
           fi
           echo "java_latest=$java_latest" >> $GITHUB_OUTPUT
 
+          php_latest="${{ github.event.inputs.php_sdk_version }}"
+          if [ -z "$php_latest" ]; then
+            php_latest=$(./temporal-features latest-sdk-version --lang php)
+            echo "Derived latest PHP SDK release version: $php_latest"
+          fi
+          echo "php_latest=$php_latest" >> $GITHUB_OUTPUT
+
           python_latest="${{ github.event.inputs.python_sdk_version }}"
           if [ -z "$python_latest" ]; then
             python_latest=$(./temporal-features latest-sdk-version --lang py)
@@ -209,6 +220,6 @@ jobs:
       go-ver: 'v${{ needs.build-go.outputs.go_latest }}'
       ts-ver: 'v${{ needs.build-go.outputs.typescript_latest }}'
       java-ver: 'v${{ needs.build-go.outputs.java_latest }}'
-      php-ver: '${{ needs.build-go.outputs.php_latest }}'
+      php-ver: 'v${{ needs.build-go.outputs.php_latest }}'
       py-ver: 'v${{ needs.build-go.outputs.python_latest }}'
       cs-ver: 'v${{ needs.build-go.outputs.csharp_latest }}'

cmd/prepare.go

@@ -90,6 +90,8 @@ func (p *Preparer) Prepare(ctx context.Context) error {
 		_, err = p.BuildJavaProgram(ctx, true)
 	case "ts":
 		_, err = p.BuildTypeScriptProgram(ctx)
+	case "php":
+		_, err = p.BuildPhpProgram(ctx)
 	case "py":
 		_, err = p.BuildPythonProgram(ctx)
 	case "cs":

cmd/run.go

@@ -295,6 +295,16 @@ func (r *Runner) Run(ctx context.Context, patterns []string) error {
 		if err == nil {
 			err = r.RunTypeScriptExternal(ctx, run)
 		}
+	case "php":
+		if r.config.DirName != "" {
+			r.program, err = sdkbuild.PhpProgramFromDir(
+				filepath.Join(r.rootDir, r.config.DirName),
+				r.rootDir,
+			)
+		}
+		if err == nil {
+			err = r.RunPhpExternal(ctx, run)
+		}
 	case "py":
 		if r.config.DirName != "" {
 			r.program, err = sdkbuild.PythonProgramFromDir(filepath.Join(r.rootDir, r.config.DirName))
@@ -545,7 +555,7 @@ func (r *Runner) destroyTempDir() {
 func normalizeLangName(lang string) (string, error) {
 	// Normalize to file extension
 	switch lang {
-	case "go", "java", "ts", "py", "cs":
+	case "go", "java", "ts", "php", "py", "cs":
 	case "typescript":
 		lang = "ts"
 	case "python":
@@ -561,7 +571,7 @@ func normalizeLangName(lang string) (string, error) {
 func expandLangName(lang string) (string, error) {
 	// Expand to lang name
 	switch lang {
-	case "go", "java", "typescript", "python":
+	case "go", "java", "php", "typescript", "python":
 	case "ts":
 		lang = "typescript"
 	case "py":

cmd/run_php.go

@@ -0,0 +1,77 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"github.com/temporalio/features/harness/go/cmd"
+	"github.com/temporalio/features/sdkbuild"
+)
+
+// PreparePhpExternal prepares a PHP run without running it. The preparer
+// config directory if present is expected to be a subdirectory name just
+// beneath the root directory.
+func (p *Preparer) BuildPhpProgram(ctx context.Context) (sdkbuild.Program, error) {
+	p.log.Info("Building PHP project", "DirName", p.config.DirName)
+
+	prog, err := sdkbuild.BuildPhpProgram(ctx, sdkbuild.BuildPhpProgramOptions{
+		DirName: p.config.DirName,
+		Version: p.config.Version,
+		RootDir: p.rootDir,
+	})
+	if err != nil {
+		p.log.Error("failed preparing: %w", err)
+		return nil, fmt.Errorf("failed preparing: %w", err)
+	}
+	return prog, nil
+}
+
+// RunPhpExternal runs the PHP run in an external process. This expects
+// the server to already be started.
+func (r *Runner) RunPhpExternal(ctx context.Context, run *cmd.Run) error {
+	// If program not built, build it
+	if r.program == nil {
+		var err error
+		if r.program, err = NewPreparer(r.config.PrepareConfig).BuildPhpProgram(ctx); err != nil {
+			return err
+		}
+	}
+
+	// Compose RoadRunner command options
+	args := append(
+		[]string{
+			// Namespace
+			"namespace=" + r.config.Namespace,
+			// Server address
+			"address=" + r.config.Server,
+		},
+		// Features
+		run.ToArgs()...,
+	)
+	// TLS
+	if r.config.ClientCertPath != "" {
+		clientCertPath, err := filepath.Abs(r.config.ClientCertPath)
+		if err != nil {
+			return err
+		}
+		args = append(args, "tls.cert="+clientCertPath)
+	}
+	if r.config.ClientKeyPath != "" {
+		clientKeyPath, err := filepath.Abs(r.config.ClientKeyPath)
+		if err != nil {
+			return err
+		}
+		args = append(args, "tls.key="+clientKeyPath)
+	}
+
+	// Run
+	cmd, err := r.program.NewCommand(ctx, args...)
+	if err == nil {
+		// r.log.Debug("Running PHP separately", "Args", cmd.Args)
+		err = cmd.Run()
+	}
+	if err != nil {
+		return fmt.Errorf("failed running: %w", err)
+	}
+	return nil
+}

harness/php/.gitignore

@@ -0,0 +1,5 @@
+# PHP stuff
+vendor
+rr
+rr.exe
+composer.lock

harness/php/.rr.yaml

@@ -0,0 +1,22 @@
+version: "3"
+rpc:
+  listen: tcp://127.0.0.1:6001
+
+server:
+  command: "php worker.php"
+
+# Workflow and activity mesh service
+temporal:
+  address: ${TEMPORAL_ADDRESS:-localhost:7233}
+  namespace: ${TEMPORAL_NAMESPACE:-default}
+  activities:
+    num_workers: 2
+
+kv:
+  harness:
+    driver: memory
+    config: { }
+
+logs:
+  mode: development
+  level: info

harness/php/composer.json

@@ -0,0 +1,24 @@
+{
+  "name": "temporal/harness",
+  "type": "project",
+  "description": "Temporal SDK Harness",
+  "keywords": ["temporal", "sdk", "harness"],
+  "license": "MIT",
+  "require": {
+    "buggregator/trap": "^1.9",
+    "spiral/core": "^3.13",
+    "symfony/process": ">=6.4",
+    "temporal/sdk": "^2.11.0",
+    "webmozart/assert": "^1.11"
+  },
+  "autoload": {
+    "psr-4": {
+      "Harness\\": "src/"
+    }
+  },
+  "scripts": {
+    "rr-get": "rr get"
+  },
+  "prefer-stable": true,
+  "minimum-stability": "dev"
+}

sdkbuild/php.go

@@ -0,0 +1,137 @@
+package sdkbuild
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+// BuildPhpProgramOptions are options for BuildPhpProgram.
+type BuildPhpProgramOptions struct {
+	// Required version. If it contains a slash it is assumed to be a path with
+	// a single wheel in the dist directory. Otherwise it is a specific version
+	// (with leading "v" is trimmed if present).
+	Version string
+	// If present, this directory is expected to exist beneath base dir. Otherwise
+	// a temporary dir is created.
+	DirName string
+	RootDir string
+}
+
+// PhpProgram is a PHP-specific implementation of Program.
+type PhpProgram struct {
+	dir    string
+	source string
+}
+
+var _ Program = (*PhpProgram)(nil)
+
+// BuildPhpProgram builds a PHP program. If completed successfully, this
+// can be stored and re-obtained via PhpProgramFromDir() with the Dir() value
+func BuildPhpProgram(ctx context.Context, options BuildPhpProgramOptions) (*PhpProgram, error) {
+	// Working directory
+	// Create temp dir if needed that we will remove if creating is unsuccessful
+	var dir string
+	if options.DirName != "" {
+		dir = filepath.Join(options.RootDir, options.DirName)
+	} else {
+		var err error
+		dir, err = os.MkdirTemp(options.RootDir, "program-")
+		if err != nil {
+			return nil, fmt.Errorf("failed making temp dir: %w", err)
+		}
+	}
+
+	sourceDir := GetSourceDir(options.RootDir)
+
+	// Skip if installed
+	if st, err := os.Stat(filepath.Join(dir, "vendor")); err == nil && st.IsDir() {
+		return &PhpProgram{dir, sourceDir}, nil
+	}
+
+	// Copy composer.json from sourceDir into dir
+	data, err := os.ReadFile(filepath.Join(sourceDir, "composer.json"))
+	if err != nil {
+		return nil, fmt.Errorf("failed reading composer.json file: %w", err)
+	}
+	err = os.WriteFile(filepath.Join(dir, "composer.json"), data, 0755)
+	if err != nil {
+		return nil, fmt.Errorf("failed writing composer.json file: %w", err)
+	}
+
+	// Copy .rr.yaml from sourceDir into dir
+	data, err = os.ReadFile(filepath.Join(sourceDir, ".rr.yaml"))
+	if err != nil {
+		return nil, fmt.Errorf("failed reading .rr.yaml file: %w", err)
+	}
+	err = os.WriteFile(filepath.Join(dir, ".rr.yaml"), data, 0755)
+	if err != nil {
+		return nil, fmt.Errorf("failed writing .rr.yaml file: %w", err)
+	}
+
+	var cmd *exec.Cmd
+	// Setup required SDK version if specified
+	if options.Version != "" {
+		cmd = exec.CommandContext(ctx, "composer", "req", "temporal/sdk", options.Version, "-W", "--no-install")
+		cmd.Dir = dir
+		cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+		if err := cmd.Run(); err != nil {
+			return nil, fmt.Errorf("failed installing SDK deps: %w", err)
+		}
+	}
+
+	// Install dependencies via composer
+	cmd = exec.CommandContext(ctx, "composer", "i", "-n", "-o", "-q", "--no-scripts", "--ignore-platform-reqs")
+	cmd.Dir = dir
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("failed installing SDK deps: %w", err)
+	}
+
+	// Download RoadRunner
+	rrExe := filepath.Join(dir, "rr")
+	if runtime.GOOS == "windows" {
+		rrExe += ".exe"
+	}
+	_, err = os.Stat(rrExe)
+	if os.IsNotExist(err) {
+		cmd = exec.CommandContext(ctx, "composer", "run", "rr-get")
+		cmd.Dir = dir
+		cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+		if err := cmd.Run(); err != nil {
+			return nil, fmt.Errorf("failed downloading RoadRunner: %w", err)
+		}
+	}
+
+	return &PhpProgram{dir, sourceDir}, nil
+}
+
+// PhpProgramFromDir recreates the Php program from a Dir() result of a
+// BuildPhpProgram(). Note, the base directory of dir when it was built must
+// also be present.
+func PhpProgramFromDir(dir string, rootDir string) (*PhpProgram, error) {
+	// Quick sanity check on the presence of package.json here
+	if _, err := os.Stat(filepath.Join(dir, "composer.json")); err != nil {
+		return nil, fmt.Errorf("failed finding composer.json in dir: %w", err)
+	}
+	return &PhpProgram{dir, GetSourceDir(rootDir)}, nil
+}
+
+func GetSourceDir(rootDir string) string {
+	return filepath.Join(rootDir, "harness", "php")
+}
+
+// Dir is the directory to run in.
+func (p *PhpProgram) Dir() string { return p.dir }
+
+// NewCommand makes a new RoadRunner run command
+func (p *PhpProgram) NewCommand(ctx context.Context, args ...string) (*exec.Cmd, error) {
+	args = append([]string{filepath.Join(p.source, "runner.php")}, args...)
+	cmd := exec.CommandContext(ctx, "php", args...)
+	cmd.Dir = p.dir
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
+	return cmd, nil
+}