mxrb 0.1.0

data/lib/mxrb/runtime/docker_executor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Runtime
+    # Executes natively compiled portable applications in a Runtime container.
+    class DockerExecutor < Executor
+      private
+
+      def validate_environment!
+        raise ToolchainError, "Mendix Runtime #{@plan.runtime_path} is unavailable" unless @plan.available?
+        _, status = capture("docker", "version", "--format", "{{.Server.Version}}")
+        raise ToolchainError, "Docker daemon is unavailable" unless status.success?
+      end
+
+      def start_runtime(package, root)
+        runtime = File.join(root, "runtime")
+        FileUtils.mkdir_p(runtime)
+        output, status = capture("unzip", "-q", package, "-d", runtime)
+        raise FunctionalTestError, "could not unpack runtime:\n#{output}" unless status.success?
+
+        command = [
+          "docker", "run", "--rm", "--stop-timeout", "10",
+          "--user", "#{Process.uid}:#{Process.gid}",
+          "--mount", bind_mount(runtime, "/mendix", readonly: false),
+          "-e", "M2EE_ADMIN_PASS=mxrb-functional-test",
+          "-e", "HOME=/tmp",
+          "-w", "/mendix",
+          @plan.runtime_image,
+          "./bin/start", "etc/Default"
+        ]
+        collect_runtime({}, command, root)
+      end
+
+      def bind_mount(source, target, readonly:)
+        values = ["type=bind", "source=#{source}", "target=#{target}"]
+        values << "readonly" if readonly
+        values.join(",")
+      end
+    end
+  end
+end

data/lib/mxrb/runtime/docker_workspace.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Runtime
+    # Produces the argv-safe command for a natively compiled Runtime package.
+    class DockerWorkspace
+      attr_reader :project_path, :plan
+
+      def initialize(project_path, plan, workspace_size: "8g")
+        @project_path = File.expand_path(project_path)
+        @plan = plan
+        @workspace_size = workspace_size.to_s
+      end
+
+      def runtime_command(package_volume:, http_port: 8080, admin_port: 8090)
+        [
+          "docker", "run", "--rm",
+          "--mount", "type=volume,source=#{package_volume},target=/mendix",
+          "--tmpfs", "/mendix/data:exec,size=2g",
+          "-p", "#{Integer(http_port)}:8080",
+          "-p", "#{Integer(admin_port)}:8090",
+          "-e", "M2EE_ADMIN_PASS=mxrb-functional-test",
+          @plan.runtime_image,
+          "./bin/start", "etc/Default"
+        ]
+      end
+    end
+  end
+end

data/lib/mxrb/runtime/executor.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "tmpdir"
+
+module Mxrb
+  module Runtime
+    Execution = Data.define(
+      :result, :check_output, :build_output, :runtime_output, :elapsed
+    ) do
+      def passed? = result.passed?
+    end
+
+    # Builds a disposable project natively and converts the Runtime protocol
+    # back into Ruby result objects.
+    class Executor
+      STARTUP_ALLOWANCE = 120
+
+      def initialize(project_path, definition, plan: nil, java_home: ENV["JAVA_HOME"],
+                     output: nil, clock: Process.method(:clock_gettime))
+        @project_path = File.expand_path(project_path)
+        @definition = definition
+        @plan = plan || Toolchain.new(@project_path).plan
+        @java_home = java_home && File.expand_path(java_home)
+        @output = output
+        @clock = clock
+      end
+
+      def run
+        validate_environment!
+        started = monotonic_time
+        Dir.mktmpdir("mxrb-functional-") do |root|
+          project = copy_project(root)
+          Functional::Instrumenter.new(project, @definition).instrument!
+          check_output = check(project, root)
+          package = build(project, root)
+          runtime_output = start_runtime(package, root)
+          result = Functional::LogParser.new.parse(runtime_output)
+          raise FunctionalTestError, "runtime stopped before the test suite completed" unless result.finished?
+
+          Execution.new(
+            result, check_output, build_output(package), runtime_output,
+            monotonic_time - started
+          )
+        end
+      end
+
+      private
+
+      def validate_environment!
+        raise ToolchainError, "Mendix Runtime #{@plan.runtime_path} is unavailable" unless @plan.available?
+        unless @java_home && File.executable?(File.join(@java_home, "bin", "java"))
+          raise ToolchainError, "JAVA_HOME must point to a Java #{@plan.java_version} installation"
+        end
+      end
+
+      def copy_project(root)
+        source_dir = File.dirname(@project_path)
+        destination = File.join(root, "project")
+        FileUtils.mkdir_p(destination)
+        FileUtils.cp_r(
+          Dir.glob(File.join(source_dir, "*"), File::FNM_DOTMATCH)
+             .reject { [".", ".."].include?(File.basename(_1)) },
+          destination
+        )
+        File.join(destination, File.basename(@project_path))
+      end
+
+      def check(project, _root)
+        result = Mxrb.validate(project)
+        unless result.valid?
+          raise FunctionalTestError,
+                "MXRB validation found #{result.errors.size} error(s): #{result.errors.first}"
+        end
+
+        (["MXRB native validation passed"] + result.warnings.map { "warning: #{_1}" }).join("\n")
+      end
+
+      def build(project, root)
+        package = File.join(root, "runtime.zip")
+        deployment = File.join(File.dirname(project), 'deployment')
+        materialized = Compiler::DeploymentMaterializer.new(
+          project, deployment:, mendix_home: @plan.toolchain_path
+        ).materialize
+        jar = Compiler::ProjectJarBuilder.new(
+          project, deployment:, mendix_home: @plan.toolchain_path, java_home: @java_home
+        ).build
+        web = Compiler::WebBundleBuilder.new(
+          project, deployment:, mendix_home: @plan.toolchain_path
+        ).build
+        result = Compiler::PortablePackager.new(
+          project, deployment:, mendix_home: @plan.toolchain_path
+        ).pack(output: package, force: true)
+        @last_build_output = format(
+          'MXRB native build: Mendix %s, %d stages, %d Java sources, %d classes, ' \
+          '%d web files, %d packaged files, sha256 %s',
+          materialized.mendix_version, materialized.stages.length, jar.sources, jar.classes,
+          web.files, result.files, result.sha256
+        )
+        package
+      rescue CompilationError => e
+        raise FunctionalTestError, "MXRB native build failed: #{e.message}"
+      end
+
+      def build_output(_package) = @last_build_output
+
+      def start_runtime(package, root)
+        runtime = File.join(root, "runtime")
+        FileUtils.mkdir_p(runtime)
+        output, status = capture("unzip", "-q", package, "-d", runtime)
+        raise FunctionalTestError, "could not unpack runtime:\n#{output}" unless status.success?
+
+        command = [File.join(runtime, "bin", "start"), "etc/Default"]
+        environment = {
+          "JAVA_HOME" => @java_home,
+          "M2EE_ADMIN_PASS" => "mxrb-functional-test"
+        }
+        collect_runtime(environment, command, runtime)
+      end
+
+      def collect_runtime(environment, command, directory)
+        transcript = +""
+        deadline = monotonic_time + STARTUP_ALLOWANCE + @definition.tests.sum(&:timeout)
+        Open3.popen2e(environment, *command, chdir: directory) do |stdin, stream, thread|
+          stdin.close
+          until transcript.include?("[MXRB_TEST] DONE")
+            remaining = deadline - monotonic_time
+            raise FunctionalTestError, "functional test runtime timed out" unless remaining.positive?
+
+            ready = ::IO.select([stream], nil, nil, remaining)
+            raise FunctionalTestError, "functional test runtime timed out" unless ready
+
+            line = stream.gets
+            break unless line
+
+            transcript << line
+            @output&.write(line)
+          end
+        ensure
+          terminate(thread)
+        end
+        transcript
+      end
+
+      def terminate(thread)
+        return unless thread&.alive?
+
+        Process.kill("TERM", thread.pid)
+        thread.join(10)
+        Process.kill("KILL", thread.pid) if thread.alive?
+      rescue Errno::ESRCH
+        nil
+      ensure
+        thread&.join
+      end
+
+      def capture(*command)
+        Open3.capture2e(*command)
+      end
+
+      def monotonic_time
+        @clock.call(Process::CLOCK_MONOTONIC)
+      rescue ArgumentError
+        @clock.call
+      end
+    end
+  end
+end

data/lib/mxrb/runtime/java_locator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mxrb
+  module Runtime
+    # Resolves a version-compatible local JDK without invoking a version manager shim.
+    module JavaLocator
+      module_function
+
+      def resolve(major, configured: nil)
+        candidates = [configured, ENV['MXRB_JAVA_HOME'], ENV['JAVA_HOME']]
+                     .compact.reject { _1.to_s.empty? }
+        candidates.concat(installed(major))
+        candidates.map { File.expand_path(_1) }
+                  .find { File.executable?(File.join(_1, 'bin', 'java')) }
+      end
+
+      def installed(major)
+        %w[.asdf/installs/java .local/share/mise/installs/java].flat_map do |root|
+          Dir.glob(File.join(Dir.home, root, '*')).select do |path|
+            File.basename(path).match?(/(?:\A|[-_])#{Regexp.escape(major.to_s)}(?:[._-]|\z)/)
+          end
+        end.sort.reverse
+      end
+    end
+  end
+end