makit 0.0.143 → 0.0.145

data/lib/makit/gitlab/pipeline_service_impl.rb

@@ -0,0 +1,1536 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require "time"
+require "securerandom"
+
+module Makit
+  module Gitlab
+    # Implementation of the PipelineService gRPC service
+    # Provides methods for parsing, validating, and converting GitLab CI pipelines
+    class PipelineServiceImpl
+      # Check if gRPC service is available
+      def self.grpc_available?
+        defined?(Gitlab::Pipeline::PipelineService)
+      end
+      
+      # Parse GitLab CI YAML content into Pipeline message
+      def parse_yaml(request, _unused_call = nil)
+        begin
+          # Parse YAML content
+          yaml_data = YAML.safe_load(request.yaml_content, permitted_classes: [Symbol], aliases: true)
+          
+          # Convert to protobuf Pipeline message
+          pipeline = convert_yaml_to_pipeline(yaml_data)
+          
+          # Validate the pipeline
+          errors, warnings = validate_pipeline_data(yaml_data)
+          
+          if grpc_available?
+            Gitlab::Pipeline::ParseYamlResponse.new(
+              pipeline: pipeline,
+              errors: errors,
+              warnings: warnings,
+              success: errors.empty?
+            )
+          else
+            # Fallback response structure
+            {
+              pipeline: pipeline,
+              errors: errors,
+              warnings: warnings,
+              success: errors.empty?
+            }
+          end
+        rescue Psych::SyntaxError => e
+          if grpc_available?
+            Gitlab::Pipeline::ParseYamlResponse.new(
+              pipeline: Gitlab::Pipeline::Pipeline.new,
+              errors: ["YAML syntax error: #{e.message}"],
+              warnings: [],
+              success: false
+            )
+          else
+            {
+              pipeline: create_empty_pipeline,
+              errors: ["YAML syntax error: #{e.message}"],
+              warnings: [],
+              success: false
+            }
+          end
+        rescue StandardError => e
+          if grpc_available?
+            Gitlab::Pipeline::ParseYamlResponse.new(
+              pipeline: Gitlab::Pipeline::Pipeline.new,
+              errors: ["Parse error: #{e.message}"],
+              warnings: [],
+              success: false
+            )
+          else
+            {
+              pipeline: create_empty_pipeline,
+              errors: ["Parse error: #{e.message}"],
+              warnings: [],
+              success: false
+            }
+          end
+        end
+      end
+
+      # Convert Pipeline message back to YAML
+      def to_yaml(request, _unused_call = nil)
+        begin
+          # Convert protobuf Pipeline to YAML
+          yaml_content = convert_pipeline_to_yaml(request.pipeline, request.pretty_format, request.indent_size)
+          
+          if grpc_available?
+            Gitlab::Pipeline::ToYamlResponse.new(
+              yaml_content: yaml_content,
+              errors: [],
+              success: true
+            )
+          else
+            {
+              yaml_content: yaml_content,
+              errors: [],
+              success: true
+            }
+          end
+        rescue StandardError => e
+          if grpc_available?
+            Gitlab::Pipeline::ToYamlResponse.new(
+              yaml_content: "",
+              errors: ["YAML generation error: #{e.message}"],
+              success: false
+            )
+          else
+            {
+              yaml_content: "",
+              errors: ["YAML generation error: #{e.message}"],
+              success: false
+            }
+          end
+        end
+      end
+
+      # Validate pipeline structure
+      def validate_pipeline(request, _unused_call = nil)
+        errors = []
+        warnings = []
+        suggestions = []
+        
+        pipeline = request.pipeline
+        
+        # Basic validation
+        if pipeline.jobs.empty?
+          warnings << "Pipeline has no jobs defined"
+        end
+        
+        if pipeline.stages.empty?
+          warnings << "Pipeline has no stages defined"
+        end
+        
+        # Validate jobs
+        pipeline.jobs.each do |job_name, job|
+          job_errors, job_warnings, job_suggestions = validate_job(job_name, job, pipeline)
+          errors.concat(job_errors)
+          warnings.concat(job_warnings)
+          suggestions.concat(job_suggestions)
+        end
+        
+        # Validate stages
+        pipeline.stages.each do |stage|
+          stage_errors, stage_warnings = validate_stage(stage, pipeline)
+          errors.concat(stage_errors)
+          warnings.concat(stage_warnings)
+        end
+        
+        if grpc_available?
+          Gitlab::Pipeline::ValidatePipelineResponse.new(
+            is_valid: errors.empty?,
+            errors: errors,
+            warnings: warnings,
+            suggestions: suggestions
+          )
+        else
+          {
+            is_valid: errors.empty?,
+            errors: errors,
+            warnings: warnings,
+            suggestions: suggestions
+          }
+        end
+      end
+
+      # Merge multiple pipelines
+      def merge_pipelines(request, _unused_call = nil)
+        base = request.base_pipeline
+        override = request.override_pipeline
+        conflicts = []
+        warnings = []
+        
+        # Create merged pipeline
+        merged = create_empty_pipeline
+        
+        # Merge basic fields
+        merged.image = override.image.empty? ? base.image : override.image
+        merged.timeout = override.timeout == 0 ? base.timeout : override.timeout
+        
+        # Merge variables
+        merged.variables.merge!(base.variables)
+        override.variables.each do |key, value|
+          if merged.variables.key?(key) && merged.variables[key] != value
+            conflicts << "Variable '#{key}' has different values: '#{merged.variables[key]}' vs '#{value}'"
+          end
+          merged.variables[key] = value
+        end
+        
+        # Merge cache
+        if override.cache && !override.cache.key.empty?
+          merged.cache = override.cache
+        elsif base.cache && !base.cache.key.empty?
+          merged.cache = base.cache
+        end
+        
+        # Merge stages
+        merged.stages.concat(base.stages)
+        override.stages.each do |override_stage|
+          existing_stage = merged.stages.find { |s| s.name == override_stage.name }
+          if existing_stage
+            existing_stage.jobs.concat(override_stage.jobs)
+          else
+            merged.stages << override_stage
+          end
+        end
+        
+        # Merge jobs
+        merged.jobs.merge!(base.jobs)
+        override.jobs.each do |job_name, job|
+          if merged.jobs.key?(job_name)
+            conflicts << "Job '#{job_name}' exists in both pipelines"
+          end
+          merged.jobs[job_name] = job
+        end
+        
+        if grpc_available?
+          Gitlab::Pipeline::MergePipelinesResponse.new(
+            merged_pipeline: merged,
+            conflicts: conflicts,
+            warnings: warnings
+          )
+        else
+          {
+            merged_pipeline: merged,
+            conflicts: conflicts,
+            warnings: warnings
+          }
+        end
+      end
+
+      # Get pipeline statistics
+      def get_pipeline_stats(request, _unused_call = nil)
+        pipeline = request.pipeline
+        
+        total_artifacts = pipeline.jobs.values.sum { |job| job.artifacts_paths.length }
+        total_services = pipeline.jobs.values.sum { |job| job.services.length }
+        total_variables = pipeline.variables.length + pipeline.jobs.values.sum { |job| job.variables.length }
+        
+        if grpc_available?
+          Gitlab::Pipeline::GetPipelineStatsResponse.new(
+            total_jobs: pipeline.jobs.length,
+            total_stages: pipeline.stages.length,
+            total_artifacts: total_artifacts,
+            total_services: total_services,
+            total_variables: total_variables,
+            stage_names: pipeline.stages.map(&:name),
+            job_names: pipeline.jobs.keys
+          )
+        else
+          {
+            total_jobs: pipeline.jobs.length,
+            total_stages: pipeline.stages.length,
+            total_artifacts: total_artifacts,
+            total_services: total_services,
+            total_variables: total_variables,
+            stage_names: pipeline.stages.map(&:name),
+            job_names: pipeline.jobs.keys
+          }
+        end
+      end
+
+      # Execute a pipeline using Podman
+      def execute_pipeline(request, _unused_call = nil)
+        begin
+          execution_id = SecureRandom.uuid
+          start_time = Time.now
+          
+          # Create execution result
+          result = create_execution_result(execution_id, start_time)
+          
+          # Check if Podman is available (cross-platform)
+          podman_executable = if request.respond_to?(:podman_executable)
+            request.podman_executable || "podman"
+          else
+            request[:podman_executable] || "podman"
+          end
+          
+          # Find the actual executable path
+          found_executable = find_executable(podman_executable)
+          unless found_executable
+            return create_error_response("Podman executable '#{podman_executable}' not found or not working")
+          end
+          
+          podman_executable = found_executable
+          
+          # Get Podman version (cross-platform)
+          podman_version = capture_command_output("#{podman_executable} --version")
+          result.podman_version = podman_version
+          result.execution_host = capture_command_output("hostname")
+          
+          # Set working directory
+          working_dir = if request.respond_to?(:working_directory)
+            request.working_directory || Dir.pwd
+          else
+            request[:working_directory] || Dir.pwd
+          end
+          
+          # Execute pipeline stages
+          pipeline = if request.respond_to?(:pipeline)
+            request.pipeline
+          else
+            request[:pipeline]
+          end
+          stage_results = []
+          
+          pipeline.stages.each do |stage|
+            stage_result = execute_stage(stage, pipeline, working_dir, request, execution_id, podman_executable)
+            stage_results << stage_result
+            result.job_results.concat(stage_result.job_results)
+          end
+          
+          # Determine overall status
+          result.status = determine_pipeline_status(result.job_results)
+          result.finished_at = Time.now
+          result.total_duration_seconds = (result.finished_at - start_time).to_i
+          
+          # Add execution logs
+          result.logs.push("Pipeline execution started at #{start_time}")
+          result.logs.push("Pipeline execution completed at #{result.finished_at}")
+          result.logs.push("Total duration: #{result.total_duration_seconds} seconds")
+          result.logs.push("Podman version: #{podman_version}")
+          
+          if grpc_available?
+            Gitlab::Pipeline::ExecutePipelineResponse.new(
+              result: result,
+              success: result.status == Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS,
+              errors: result.errors,
+              warnings: result.warnings
+            )
+          else
+            {
+              result: result,
+              success: result.status == :success,
+              errors: result.errors,
+              warnings: result.warnings
+            }
+          end
+          
+        rescue StandardError => e
+          error_result = create_execution_result(SecureRandom.uuid, Time.now)
+          error_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+          error_result.errors.push("Pipeline execution failed: #{e.message}")
+          error_result.logs.push("Error: #{e.message}")
+          error_result.logs.push("Backtrace: #{e.backtrace.join("\n")}")
+          
+          if grpc_available?
+            Gitlab::Pipeline::ExecutePipelineResponse.new(
+              result: error_result,
+              success: false,
+              errors: error_result.errors,
+              warnings: error_result.warnings
+            )
+          else
+            {
+              result: error_result,
+              success: false,
+              errors: error_result.errors,
+              warnings: error_result.warnings
+            }
+          end
+        end
+      end
+
+      # Compare two pipelines
+      def compare_pipelines(request, _unused_call = nil)
+        pipeline1 = request.pipeline1
+        pipeline2 = request.pipeline2
+        
+        differences = []
+        added_jobs = []
+        removed_jobs = []
+        modified_jobs = []
+        added_stages = []
+        removed_stages = []
+        
+        # Compare jobs
+        pipeline1_jobs = pipeline1.jobs.keys.to_set
+        pipeline2_jobs = pipeline2.jobs.keys.to_set
+        
+        added_jobs = (pipeline2_jobs - pipeline1_jobs).to_a
+        removed_jobs = (pipeline1_jobs - pipeline2_jobs).to_a
+        
+        common_jobs = pipeline1_jobs & pipeline2_jobs
+        common_jobs.each do |job_name|
+          job1 = pipeline1.jobs[job_name]
+          job2 = pipeline2.jobs[job_name]
+          unless jobs_equal?(job1, job2)
+            modified_jobs << job_name
+            differences << "Job '#{job_name}' has been modified"
+          end
+        end
+        
+        # Compare stages
+        pipeline1_stages = pipeline1.stages.map(&:name).to_set
+        pipeline2_stages = pipeline2.stages.map(&:name).to_set
+        
+        added_stages = (pipeline2_stages - pipeline1_stages).to_a
+        removed_stages = (pipeline1_stages - pipeline2_stages).to_a
+        
+        if grpc_available?
+          Gitlab::Pipeline::ComparePipelinesResponse.new(
+            are_identical: differences.empty? && added_jobs.empty? && removed_jobs.empty? && added_stages.empty? && removed_stages.empty?,
+            differences: differences,
+            added_jobs: added_jobs,
+            removed_jobs: removed_jobs,
+            modified_jobs: modified_jobs,
+            added_stages: added_stages,
+            removed_stages: removed_stages
+          )
+        else
+          {
+            are_identical: differences.empty? && added_jobs.empty? && removed_jobs.empty? && added_stages.empty? && removed_stages.empty?,
+            differences: differences,
+            added_jobs: added_jobs,
+            removed_jobs: removed_jobs,
+            modified_jobs: modified_jobs,
+            added_stages: added_stages,
+            removed_stages: removed_stages
+          }
+        end
+      end
+
+      private
+
+      def grpc_available?
+        self.class.grpc_available?
+      end
+
+      # Cross-platform command execution helper
+      def capture_command_output(command)
+        if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+          # Windows: Use PowerShell call operator for paths with spaces
+          if command.include?('"') && command.include?(' ')
+            # Command already has quotes, use PowerShell call operator
+            powershell_cmd = "& #{command}"
+            `powershell -Command "#{powershell_cmd}" 2>nul`.strip
+          else
+            # Simple command without spaces
+            `#{command} 2>nul`.strip
+          end
+        else
+          # Unix-like systems (Linux, macOS)
+          `#{command} 2>/dev/null`.strip
+        end
+      rescue StandardError
+        ""
+      end
+
+      # Cross-platform executable detection
+      def find_executable(executable_name)
+        if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+          # Windows - check common locations and extensions
+          extensions = ['.exe', '.bat', '.cmd', '']
+          paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+          
+          extensions.each do |ext|
+            full_name = executable_name + ext
+            paths.each do |path|
+              full_path = File.join(path, full_name)
+              return full_path if File.executable?(full_path)
+            end
+          end
+          
+          # Try direct execution
+          return executable_name if system("#{executable_name} --version", out: File::NULL, err: File::NULL)
+        else
+          # Unix-like systems
+          return executable_name if system("which #{executable_name} > /dev/null 2>&1")
+        end
+        
+        nil
+      end
+
+      # Create execution result object
+      def create_execution_result(execution_id, start_time)
+        if grpc_available?
+          Gitlab::Pipeline::PipelineExecutionResult.new(
+            execution_id: execution_id,
+            status: Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_RUNNING,
+            started_at: start_time.iso8601,
+            job_results: [],
+            logs: [],
+            errors: [],
+            warnings: []
+          )
+        else
+          result = Object.new
+          
+          # Initialize instance variables
+          result.instance_variable_set(:@execution_id, execution_id)
+          result.instance_variable_set(:@status, :running)
+          result.instance_variable_set(:@started_at, start_time.iso8601)
+          result.instance_variable_set(:@job_results, [])
+          result.instance_variable_set(:@logs, [])
+          result.instance_variable_set(:@errors, [])
+          result.instance_variable_set(:@warnings, [])
+          
+          # Add getter and setter methods for fallback
+          def result.execution_id
+            @execution_id
+          end
+          
+          def result.execution_id=(value)
+            @execution_id = value
+          end
+          
+          def result.status=(value)
+            @status = value
+          end
+          
+          def result.status
+            @status
+          end
+          
+          def result.started_at
+            @started_at
+          end
+          
+          def result.started_at=(value)
+            @started_at = value
+          end
+          
+          def result.finished_at=(value)
+            @finished_at = value
+          end
+          
+          def result.finished_at
+            @finished_at
+          end
+          
+          def result.total_duration_seconds=(value)
+            @total_duration_seconds = value
+          end
+          
+          def result.total_duration_seconds
+            @total_duration_seconds
+          end
+          
+          def result.podman_version=(value)
+            @podman_version = value
+          end
+          
+          def result.podman_version
+            @podman_version
+          end
+          
+          def result.execution_host=(value)
+            @execution_host = value
+          end
+          
+          def result.execution_host
+            @execution_host
+          end
+          
+          def result.job_results
+            @job_results
+          end
+          
+          def result.job_results=(value)
+            @job_results = value
+          end
+          
+          def result.errors
+            @errors
+          end
+          
+          def result.errors=(value)
+            @errors = value
+          end
+          
+          def result.warnings
+            @warnings
+          end
+          
+          def result.warnings=(value)
+            @warnings = value
+          end
+          
+          def result.logs
+            @logs
+          end
+          
+          def result.logs=(value)
+            @logs = value
+          end
+          
+          result
+        end
+      end
+
+      # Create error response
+      def create_error_response(message)
+        error_result = create_execution_result(SecureRandom.uuid, Time.now)
+        error_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+        error_result.errors.push(message)
+        error_result.logs.push("Error: #{message}")
+        
+        if grpc_available?
+          Gitlab::Pipeline::ExecutePipelineResponse.new(
+            result: error_result,
+            success: false,
+            errors: error_result.errors,
+            warnings: error_result.warnings
+          )
+        else
+          {
+            result: error_result,
+            success: false,
+            errors: error_result.errors,
+            warnings: error_result.warnings
+          }
+        end
+      end
+
+      # Execute a single stage
+      def execute_stage(stage, pipeline, working_dir, request, execution_id, podman_executable)
+        stage_result = if grpc_available?
+          Gitlab::Pipeline::StageExecutionResult.new(
+            stage_name: stage.name,
+            status: Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_RUNNING,
+            started_at: Time.now.iso8601,
+            job_results: []
+          )
+        else
+          stage_result = Object.new
+          
+          # Initialize instance variables
+          stage_result.instance_variable_set(:@stage_name, stage.name)
+          stage_result.instance_variable_set(:@status, :running)
+          stage_result.instance_variable_set(:@started_at, Time.now.iso8601)
+          stage_result.instance_variable_set(:@job_results, [])
+          
+          # Add getter and setter methods for fallback
+          def stage_result.stage_name
+            @stage_name
+          end
+          
+          def stage_result.stage_name=(value)
+            @stage_name = value
+          end
+          
+          def stage_result.status=(value)
+            @status = value
+          end
+          
+          def stage_result.status
+            @status
+          end
+          
+          def stage_result.started_at
+            @started_at
+          end
+          
+          def stage_result.started_at=(value)
+            @started_at = value
+          end
+          
+          def stage_result.finished_at=(value)
+            @finished_at = value
+          end
+          
+          def stage_result.finished_at
+            @finished_at
+          end
+          
+          def stage_result.job_results
+            @job_results
+          end
+          
+          def stage_result.job_results=(value)
+            @job_results = value
+          end
+          
+          stage_result
+        end
+
+        # Find jobs for this stage
+        stage_jobs = pipeline.jobs.select { |name, job| job.stage == stage.name }
+        
+        stage_jobs.each do |job_name, job|
+          job_result = execute_job(job_name, job, pipeline, working_dir, request, execution_id, podman_executable)
+          stage_result.job_results.push(job_result)
+        end
+
+        # Determine stage status
+        stage_result.status = determine_stage_status(stage_result.job_results)
+        stage_result.finished_at = Time.now.iso8601
+
+        stage_result
+      end
+
+      # Execute a single job
+      def execute_job(job_name, job, pipeline, working_dir, request, execution_id, podman_executable)
+        job_result = if grpc_available?
+          Gitlab::Pipeline::JobExecutionResult.new(
+            job_name: job_name,
+            status: Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_RUNNING,
+            started_at: Time.now.iso8601,
+            logs: [],
+            errors: []
+          )
+        else
+          job_result = Object.new
+          
+          # Initialize instance variables
+          job_result.instance_variable_set(:@job_name, job_name)
+          job_result.instance_variable_set(:@status, :running)
+          job_result.instance_variable_set(:@started_at, Time.now.iso8601)
+          job_result.instance_variable_set(:@logs, [])
+          job_result.instance_variable_set(:@errors, [])
+          job_result.instance_variable_set(:@stdout, "")
+          job_result.instance_variable_set(:@stderr, "")
+          
+          # Add getter and setter methods for fallback
+          def job_result.job_name
+            @job_name
+          end
+          
+          def job_result.job_name=(value)
+            @job_name = value
+          end
+          
+          def job_result.status=(value)
+            @status = value
+          end
+          
+          def job_result.status
+            @status
+          end
+          
+          def job_result.started_at
+            @started_at
+          end
+          
+          def job_result.started_at=(value)
+            @started_at = value
+          end
+          
+          def job_result.finished_at=(value)
+            @finished_at = value
+          end
+          
+          def job_result.finished_at
+            @finished_at
+          end
+          
+          def job_result.exit_code=(value)
+            @exit_code = value
+          end
+          
+          def job_result.exit_code
+            @exit_code
+          end
+          
+          def job_result.logs
+            @logs
+          end
+          
+          def job_result.logs=(value)
+            @logs = value
+          end
+          
+          def job_result.errors
+            @errors
+          end
+          
+          def job_result.errors=(value)
+            @errors = value
+          end
+          
+          def job_result.stdout=(value)
+            @stdout = value
+          end
+          
+          def job_result.stdout
+            @stdout
+          end
+          
+          def job_result.stderr=(value)
+            @stderr = value
+          end
+          
+          def job_result.stderr
+            @stderr
+          end
+          
+          job_result
+        end
+
+        begin
+          # Check if this is a dry run
+          dry_run = if request.respond_to?(:dry_run)
+            request.dry_run
+          else
+            request[:dry_run]
+          end
+          
+          if dry_run
+            job_result.logs.push("DRY RUN: Would execute job: #{job_name}")
+            job_result.logs.push("DRY RUN: Skipping actual execution")
+            job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success
+            job_result.exit_code = 0
+            job_result.finished_at = Time.now.iso8601
+            return job_result
+          end
+          
+          job_result.logs.push("Executing job: #{job_name}")
+          
+          # Use the new Podman service for cleaner execution
+          podman_service = Makit::Podman::Podman.new(podman_executable: podman_executable)
+          
+          # Build script content
+          script_content = build_job_script(job, pipeline)
+          
+          # Prepare environment variables
+          environment = {}
+          pipeline.variables.each { |k, v| environment[k] = v }
+          (request.respond_to?(:variables) ? request.variables : request[:variables]).each { |k, v| environment[k] = v }
+          
+          # Prepare volume mounts
+          volume_mounts = [
+            podman_service.create_volume_mount(
+              host_path: working_dir,
+              container_path: "/workspace",
+              mode: "rw"
+            )
+          ]
+          
+          # Determine image to use
+          image = (job.image && !job.image.empty?) ? job.image : pipeline.image
+          image = "alpine:latest" if image.empty?
+          
+          job_result.logs.push("Using image: #{image}")
+          job_result.logs.push("Working directory: #{working_dir}")
+          
+          # Execute script using Podman service
+          result = podman_service.run_script(
+            image,
+            script_content,
+            environment: environment,
+            volume_mounts: volume_mounts,
+            working_directory: "/tmp",
+            timeout: 300,
+            auto_remove: true,
+            name: "#{execution_id}-#{job_name}".gsub(/[^a-zA-Z0-9_-]/, '-')
+          )
+          
+          # Process results
+          if result.respond_to?(:success)
+            # gRPC mode
+            job_result.exit_code = result.exit_code
+            job_result.finished_at = Time.now.iso8601
+            
+            if result.success
+              job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success
+              job_result.stdout = result.stdout if result.stdout
+              job_result.stderr = result.stderr if result.stderr
+            else
+              job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+              job_result.errors.push("Job failed with exit code #{result.exit_code}")
+              job_result.stdout = result.stdout if result.stdout
+              job_result.stderr = result.stderr if result.stderr
+            end
+          else
+            # Fallback mode
+            job_result.exit_code = result[:exit_code]
+            job_result.finished_at = Time.now.iso8601
+            
+            if result[:success]
+              job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success
+              job_result.stdout = result[:stdout] if result[:stdout]
+              job_result.stderr = result[:stderr] if result[:stderr]
+            else
+              job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+              job_result.errors.push("Job failed with exit code #{result[:exit_code]}")
+              job_result.stdout = result[:stdout] if result[:stdout]
+              job_result.stderr = result[:stderr] if result[:stderr]
+            end
+          end
+          
+        rescue StandardError => e
+          job_result.status = grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+          job_result.errors.push("Job execution error: #{e.message}")
+          job_result.logs.push("Error: #{e.message}")
+          job_result.finished_at = Time.now.iso8601
+        end
+
+        job_result
+      end
+
+             # Build job script content
+             def build_job_script(job, pipeline)
+               script_lines = []
+               
+               # Add shebang and environment setup for Unix containers (ensure clean lines)
+               script_lines.push("#!/bin/sh")
+               script_lines.push("set -e")
+               
+               # Fix directory permissions for Bundler security BEFORE any commands run
+               script_lines.push("chmod 755 /workspace")
+               script_lines.push("mkdir -p /workspace/vendor/ruby")
+               script_lines.push("chmod 755 /workspace/vendor/ruby")
+               script_lines.push("chmod 755 /workspace/vendor")
+               script_lines.push("chmod 755 /workspace/vendor/ruby/ruby")
+               script_lines.push("mkdir -p /workspace/vendor/ruby/ruby/3.4.0/gems")
+               script_lines.push("chmod 755 /workspace/vendor/ruby/ruby/3.4.0/gems")
+               
+               # Add before_script if present, but modify Bundler commands to use secure path
+               if pipeline.before_script && !pipeline.before_script.empty?
+                 pipeline.before_script.each do |line|
+                   # Normalize line endings and fix command substitutions
+                   normalized_line = normalize_script_line(line)
+                   
+                   # Replace insecure Bundler path configuration with secure path
+                   if normalized_line.include?("bundle config set --local path 'vendor/ruby'")
+                     script_lines.push("bundle config set --local path '/tmp/bundle'")
+                     script_lines.push("mkdir -p /tmp/bundle")
+                     script_lines.push("chmod 755 /tmp/bundle")
+                   else
+                     script_lines.push(normalized_line)
+                   end
+                 end
+               end
+               
+               # Add job script
+               if job.script && !job.script.empty?
+                 job.script.each do |line|
+                   # Normalize line endings and fix command substitutions
+                   normalized_line = normalize_script_line(line)
+                   script_lines.push(normalized_line)
+                 end
+               end
+               
+               # Add after_script if present
+               if pipeline.after_script && !pipeline.after_script.empty?
+                 pipeline.after_script.each do |line|
+                   # Normalize line endings and fix command substitutions
+                   normalized_line = normalize_script_line(line)
+                   script_lines.push(normalized_line)
+                 end
+               end
+               
+               script_lines.join("\n")
+             end
+             
+             # Normalize script line to handle Windows line endings and command substitutions
+             def normalize_script_line(line)
+               # Normalize line endings to Unix format
+               normalized = line.gsub(/\r\n/, "\n").gsub(/\r/, "\n").strip
+               
+               # Fix common command substitutions that might have Windows line endings
+               # Replace $(nproc) with a safer version that strips line endings
+               normalized = normalized.gsub(/\$\(nproc\)/, '$(nproc | tr -d "\\r\\n")')
+               
+               # Fix other common command substitutions
+               normalized = normalized.gsub(/\$\(([^)]+)\)/) do |match|
+                 cmd = $1
+                 # For commands that might return line endings, wrap them
+                 if cmd.match?(/^(nproc|hostname|pwd|whoami)$/)
+                   "$(#{cmd} | tr -d \"\\r\\n\")"
+                 else
+                   match
+                 end
+               end
+               
+               normalized
+             end
+
+      # Determine pipeline status from job results
+      def determine_pipeline_status(job_results)
+        return grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success if job_results.empty?
+        
+        failed_jobs = job_results.select do |job|
+          if grpc_available?
+            job.status == Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED
+          else
+            job.status == :failed
+          end
+        end
+        
+        if failed_jobs.any?
+          grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+        else
+          grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success
+        end
+      end
+
+      # Determine stage status from job results
+      def determine_stage_status(job_results)
+        return grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success if job_results.empty?
+        
+        failed_jobs = job_results.select do |job|
+          if grpc_available?
+            job.status == Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED
+          else
+            job.status == :failed
+          end
+        end
+        
+        if failed_jobs.any?
+          grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_FAILED : :failed
+        else
+          grpc_available? ? Gitlab::Pipeline::PipelineStatus::PIPELINE_STATUS_SUCCESS : :success
+        end
+      end
+
+      def create_empty_pipeline
+        if grpc_available?
+          Gitlab::Pipeline::Pipeline.new
+        else
+          create_empty_pipeline_fallback
+        end
+      end
+
+      def create_empty_pipeline_fallback
+        pipeline = Object.new
+        
+        def pipeline.image
+          @image ||= ""
+        end
+        
+        def pipeline.image=(value)
+          @image = value
+        end
+        
+        def pipeline.jobs
+          @jobs ||= {}
+        end
+        
+        def pipeline.stages
+          @stages ||= []
+        end
+        
+        def pipeline.variables
+          @variables ||= {}
+        end
+        
+        def pipeline.cache
+          @cache ||= nil
+        end
+        
+        def pipeline.cache=(value)
+          @cache = value
+        end
+        
+        def pipeline.before_script
+          @before_script ||= []
+        end
+        
+        def pipeline.after_script
+          @after_script ||= []
+        end
+        
+        def pipeline.timeout
+          @timeout ||= 0
+        end
+        
+        def pipeline.timeout=(value)
+          @timeout = value
+        end
+        
+        pipeline
+      end
+
+      # Convert YAML data to protobuf Pipeline
+      def convert_yaml_to_pipeline(yaml_data)
+        if grpc_available?
+          convert_yaml_to_pipeline_grpc(yaml_data)
+        else
+          convert_yaml_to_pipeline_fallback(yaml_data)
+        end
+      end
+
+      def convert_yaml_to_pipeline_grpc(yaml_data)
+        pipeline = Gitlab::Pipeline::Pipeline.new
+        
+        pipeline.image = yaml_data["image"] || ""
+        pipeline.timeout = yaml_data["timeout"] || 0
+        
+        # Convert variables
+        if yaml_data["variables"]
+          yaml_data["variables"].each do |key, value|
+            pipeline.variables[key] = value.to_s
+          end
+        end
+        
+        # Convert cache
+        if yaml_data["cache"]
+          cache = Gitlab::Pipeline::Cache.new
+          cache.key = yaml_data["cache"]["key"] || ""
+          cache.policy = yaml_data["cache"]["policy"] || ""
+          cache.expire_in = yaml_data["cache"]["expire_in"] || 0
+          if yaml_data["cache"]["paths"]
+            cache.paths.concat(yaml_data["cache"]["paths"])
+          end
+          pipeline.cache = cache
+        end
+        
+        # Convert before_script and after_script
+        pipeline.before_script.concat(yaml_data["before_script"] || [])
+        pipeline.after_script.concat(yaml_data["after_script"] || [])
+        
+        # Convert stages
+        if yaml_data["stages"]
+          yaml_data["stages"].each do |stage_name|
+            stage = Gitlab::Pipeline::Stage.new
+            stage.name = stage_name
+            pipeline.stages << stage
+          end
+        end
+        
+        # Convert jobs
+        yaml_data.each do |key, value|
+          next if %w[image variables cache before_script after_script stages include extends services tags timeout].include?(key)
+          
+          if value.is_a?(Hash)
+            job = convert_yaml_to_job_grpc(value)
+            pipeline.jobs[key] = job
+          end
+        end
+        
+        pipeline
+      end
+
+      def convert_yaml_to_pipeline_fallback(yaml_data)
+        pipeline = create_empty_pipeline_fallback
+        
+        # Set basic properties
+        pipeline.image = yaml_data["image"] || ""
+        pipeline.timeout = yaml_data["timeout"] || 0
+        
+        # Set variables
+        if yaml_data["variables"]
+          pipeline.variables.merge!(yaml_data["variables"])
+        end
+        
+        # Set scripts
+        pipeline.before_script.concat(yaml_data["before_script"] || [])
+        pipeline.after_script.concat(yaml_data["after_script"] || [])
+        
+        # Set stages
+        if yaml_data["stages"]
+          yaml_data["stages"].each do |stage_name|
+            stage = Object.new
+            def stage.name
+              @name
+            end
+            def stage.name=(value)
+              @name = value
+            end
+            stage.name = stage_name
+            pipeline.stages << stage
+          end
+        end
+        
+        # Set jobs
+        yaml_data.each do |key, value|
+          next if %w[image variables cache before_script after_script stages include extends services tags timeout].include?(key)
+          
+          if value.is_a?(Hash)
+            job = convert_yaml_to_job_fallback(value)
+            pipeline.jobs[key] = job
+          end
+        end
+        
+        pipeline
+      end
+
+      # Convert YAML job data to protobuf Job
+      def convert_yaml_to_job(yaml_data)
+        if grpc_available?
+          convert_yaml_to_job_grpc(yaml_data)
+        else
+          convert_yaml_to_job_fallback(yaml_data)
+        end
+      end
+
+      def convert_yaml_to_job_grpc(yaml_data)
+        job = Gitlab::Pipeline::Job.new
+        
+        job.stage = yaml_data["stage"] || ""
+        job.image = yaml_data["image"] || ""
+        job.artifacts_when = yaml_data.dig("artifacts", "when") || ""
+        job.coverage = yaml_data["coverage"] || ""
+        job.allow_failure = yaml_data["allow_failure"] || false
+        job.timeout = yaml_data["timeout"] || 0
+        
+        # Convert script arrays
+        job.script.concat(yaml_data["script"] || [])
+        job.before_script.concat(yaml_data["before_script"] || [])
+        job.after_script.concat(yaml_data["after_script"] || [])
+        job.dependencies.concat(yaml_data["dependencies"] || [])
+        job.services.concat(yaml_data["services"] || [])
+        job.tags.concat(yaml_data["tags"] || [])
+        job.needs.concat(yaml_data["needs"] || [])
+        job.when.concat(yaml_data["when"] || [])
+        job.only.concat(yaml_data["only"] || [])
+        job.except.concat(yaml_data["except"] || [])
+        job.rules.concat(yaml_data["rules"] || [])
+        
+        # Convert artifacts
+        if yaml_data["artifacts"]
+          artifacts = yaml_data["artifacts"]
+          job.artifacts_paths.concat(artifacts["paths"] || [])
+          job.artifacts_expire_in = artifacts["expire_in"] || 0
+          job.artifacts_when = artifacts["when"] || ""
+          job.artifacts_name.concat(artifacts["name"] || [])
+          job.artifacts_untracked.concat(artifacts["untracked"] || [])
+          job.artifacts_reports.concat(artifacts["reports"] || [])
+          job.artifacts_expose_as.concat(artifacts["expose_as"] || [])
+        end
+        
+        # Convert variables
+        if yaml_data["variables"]
+          yaml_data["variables"].each do |key, value|
+            job.variables[key] = value.to_s
+          end
+        end
+        
+        job
+      end
+
+      def convert_yaml_to_job_fallback(yaml_data)
+        job = Object.new
+        
+        def job.stage
+          @stage ||= ""
+        end
+        
+        def job.stage=(value)
+          @stage = value
+        end
+        
+        def job.script
+          @script ||= []
+        end
+        
+        def job.before_script
+          @before_script ||= []
+        end
+        
+        def job.after_script
+          @after_script ||= []
+        end
+        
+        def job.image
+          @image ||= ""
+        end
+        
+        def job.image=(value)
+          @image = value
+        end
+        
+        def job.variables
+          @variables ||= {}
+        end
+        
+        def job.services
+          @services ||= []
+        end
+        
+        def job.tags
+          @tags ||= []
+        end
+        
+        def job.artifacts_paths
+          @artifacts_paths ||= []
+        end
+        
+        def job.artifacts_when
+          @artifacts_when ||= ""
+        end
+        
+        def job.artifacts_when=(value)
+          @artifacts_when = value
+        end
+        
+        def job.coverage
+          @coverage ||= ""
+        end
+        
+        def job.coverage=(value)
+          @coverage = value
+        end
+        
+        def job.allow_failure
+          @allow_failure ||= false
+        end
+        
+        def job.allow_failure=(value)
+          @allow_failure = value
+        end
+        
+        def job.timeout
+          @timeout ||= 0
+        end
+        
+        def job.timeout=(value)
+          @timeout = value
+        end
+        
+        def job.dependencies
+          @dependencies ||= []
+        end
+        
+        def job.needs
+          @needs ||= []
+        end
+        
+        def job.when
+          @when ||= []
+        end
+        
+        def job.only
+          @only ||= []
+        end
+        
+        def job.except
+          @except ||= []
+        end
+        
+        def job.rules
+          @rules ||= []
+        end
+        
+        # Set job properties
+        job.stage = yaml_data["stage"] || ""
+        job.image = yaml_data["image"] || ""
+        job.coverage = yaml_data["coverage"] || ""
+        job.allow_failure = yaml_data["allow_failure"] || false
+        job.timeout = yaml_data["timeout"] || 0
+        
+        # Set script arrays
+        job.script.concat(yaml_data["script"] || [])
+        job.before_script.concat(yaml_data["before_script"] || [])
+        job.after_script.concat(yaml_data["after_script"] || [])
+        job.dependencies.concat(yaml_data["dependencies"] || [])
+        job.services.concat(yaml_data["services"] || [])
+        job.tags.concat(yaml_data["tags"] || [])
+        job.needs.concat(yaml_data["needs"] || [])
+        job.when.concat(yaml_data["when"] || [])
+        job.only.concat(yaml_data["only"] || [])
+        job.except.concat(yaml_data["except"] || [])
+        job.rules.concat(yaml_data["rules"] || [])
+        
+        # Set artifacts
+        if yaml_data["artifacts"]
+          artifacts = yaml_data["artifacts"]
+          job.artifacts_paths.concat(artifacts["paths"] || [])
+          job.artifacts_when = artifacts["when"] || ""
+        end
+        
+        # Set variables
+        if yaml_data["variables"]
+          job.variables.merge!(yaml_data["variables"])
+        end
+        
+        job
+      end
+
+      # Convert protobuf Pipeline to YAML
+      def convert_pipeline_to_yaml(pipeline, pretty_format = true, indent_size = 2)
+        yaml_data = {}
+        
+        # Add basic fields
+        yaml_data["image"] = pipeline.image unless pipeline.image.empty?
+        yaml_data["timeout"] = pipeline.timeout unless pipeline.timeout == 0
+        
+        # Add variables
+        unless pipeline.variables.empty?
+          yaml_data["variables"] = pipeline.variables.to_h
+        end
+        
+        # Add cache
+        if pipeline.cache && !pipeline.cache.key.empty?
+          cache_data = {}
+          cache_data["key"] = pipeline.cache.key
+          cache_data["policy"] = pipeline.cache.policy unless pipeline.cache.policy.empty?
+          cache_data["expire_in"] = pipeline.cache.expire_in unless pipeline.cache.expire_in == 0
+          cache_data["paths"] = pipeline.cache.paths.to_a unless pipeline.cache.paths.empty?
+          yaml_data["cache"] = cache_data
+        end
+        
+        # Add scripts
+        yaml_data["before_script"] = pipeline.before_script.to_a unless pipeline.before_script.empty?
+        yaml_data["after_script"] = pipeline.after_script.to_a unless pipeline.after_script.empty?
+        
+        # Add stages
+        unless pipeline.stages.empty?
+          yaml_data["stages"] = pipeline.stages.map(&:name)
+        end
+        
+        # Add jobs
+        pipeline.jobs.each do |job_name, job|
+          yaml_data[job_name] = convert_job_to_yaml(job)
+        end
+        
+        # Add other fields
+        yaml_data["include"] = pipeline.include.to_a unless pipeline.include.empty?
+        yaml_data["extends"] = pipeline.extends.to_a unless pipeline.extends.empty?
+        yaml_data["services"] = pipeline.services.to_a unless pipeline.services.empty?
+        yaml_data["tags"] = pipeline.tags.to_a unless pipeline.tags.empty?
+        
+        if pretty_format
+          YAML.dump(yaml_data)
+        else
+          yaml_data.to_yaml
+        end
+      end
+
+      # Convert protobuf Job to YAML
+      def convert_job_to_yaml(job)
+        job_data = {}
+        
+        # Add basic fields
+        job_data["stage"] = job.stage unless job.stage.empty?
+        job_data["image"] = job.image unless job.image.empty?
+        job_data["coverage"] = job.coverage unless job.coverage.empty?
+        job_data["allow_failure"] = job.allow_failure if job.allow_failure
+        job_data["timeout"] = job.timeout unless job.timeout == 0
+        
+        # Add script arrays
+        job_data["script"] = job.script.to_a unless job.script.empty?
+        job_data["before_script"] = job.before_script.to_a unless job.before_script.empty?
+        job_data["after_script"] = job.after_script.to_a unless job.after_script.empty?
+        job_data["dependencies"] = job.dependencies.to_a unless job.dependencies.empty?
+        job_data["services"] = job.services.to_a unless job.services.empty?
+        job_data["tags"] = job.tags.to_a unless job.tags.empty?
+        job_data["needs"] = job.needs.to_a unless job.needs.empty?
+        job_data["when"] = job.when.to_a unless job.when.empty?
+        job_data["only"] = job.only.to_a unless job.only.empty?
+        job_data["except"] = job.except.to_a unless job.except.empty?
+        job_data["rules"] = job.rules.to_a unless job.rules.empty?
+        
+        # Add artifacts
+        if !job.artifacts_paths.empty? || !job.artifacts_when.empty? || job.artifacts_expire_in != 0
+          artifacts_data = {}
+          artifacts_data["paths"] = job.artifacts_paths.to_a unless job.artifacts_paths.empty?
+          artifacts_data["when"] = job.artifacts_when unless job.artifacts_when.empty?
+          artifacts_data["expire_in"] = job.artifacts_expire_in unless job.artifacts_expire_in == 0
+          artifacts_data["name"] = job.artifacts_name.to_a unless job.artifacts_name.empty?
+          artifacts_data["untracked"] = job.artifacts_untracked.to_a unless job.artifacts_untracked.empty?
+          artifacts_data["reports"] = job.artifacts_reports.to_a unless job.artifacts_reports.empty?
+          artifacts_data["expose_as"] = job.artifacts_expose_as.to_a unless job.artifacts_expose_as.empty?
+          job_data["artifacts"] = artifacts_data
+        end
+        
+        # Add variables
+        unless job.variables.empty?
+          job_data["variables"] = job.variables.to_h
+        end
+        
+        job_data
+      end
+
+      # Validate pipeline data
+      def validate_pipeline_data(yaml_data)
+        errors = []
+        warnings = []
+        
+        # Check for required fields
+        unless yaml_data["stages"] || yaml_data.keys.any? { |k| k.is_a?(String) && !%w[image variables cache before_script after_script include extends services tags timeout].include?(k) }
+          warnings << "Pipeline has no stages or jobs defined"
+        end
+        
+        errors
+      end
+
+      # Validate individual job
+      def validate_job(job_name, job, pipeline)
+        errors = []
+        warnings = []
+        suggestions = []
+        
+        # Check if job stage exists
+        if !job.stage.empty? && !pipeline.stages.any? { |s| s.name == job.stage }
+          errors << "Job '#{job_name}' references non-existent stage '#{job.stage}'"
+        end
+        
+        # Check for required fields
+        if job.script.empty?
+          warnings << "Job '#{job_name}' has no script defined"
+        end
+        
+        # Check dependencies
+        job.dependencies.each do |dep|
+          unless pipeline.jobs.key?(dep)
+            errors << "Job '#{job_name}' depends on non-existent job '#{dep}'"
+          end
+        end
+        
+        # Check needs
+        job.needs.each do |need|
+          unless pipeline.jobs.key?(need)
+            errors << "Job '#{job_name}' needs non-existent job '#{need}'"
+          end
+        end
+        
+        [errors, warnings, suggestions]
+      end
+
+      # Validate individual stage
+      def validate_stage(stage, pipeline)
+        errors = []
+        warnings = []
+        
+        # Check if stage has jobs
+        stage_jobs = pipeline.jobs.values.select { |job| job.stage == stage.name }
+        if stage_jobs.empty?
+          warnings << "Stage '#{stage.name}' has no jobs"
+        end
+        
+        [errors, warnings]
+      end
+
+      # Compare two jobs for equality
+      def jobs_equal?(job1, job2)
+        job1.stage == job2.stage &&
+          job1.script.to_a == job2.script.to_a &&
+          job1.before_script.to_a == job2.before_script.to_a &&
+          job1.after_script.to_a == job2.after_script.to_a &&
+          job1.dependencies.to_a == job2.dependencies.to_a &&
+          job1.artifacts_paths.to_a == job2.artifacts_paths.to_a &&
+          job1.artifacts_when == job2.artifacts_when &&
+          job1.coverage == job2.coverage &&
+          job1.variables.to_h == job2.variables.to_h &&
+          job1.image == job2.image &&
+          job1.services.to_a == job2.services.to_a &&
+          job1.tags.to_a == job2.tags.to_a &&
+          job1.allow_failure == job2.allow_failure &&
+          job1.timeout == job2.timeout &&
+          job1.needs.to_a == job2.needs.to_a
+      end
+    end
+  end
+end