makit 0.0.143 → 0.0.145

data/lib/makit/process.rb

@@ -159,5 +159,219 @@ module Makit
         results.split("\n").reject(&:empty?)
       end
     end
+
+    # Run a command in the background and track it with a PID file
+    #
+    # This method starts a process in the background and stores its PID in a file
+    # for later management. It handles cross-platform differences in process spawning.
+    #
+    # @param command [String] The command to run in the background
+    # @param pid_file [String] Path to the PID file to store the process ID
+    # @param working_dir [String, nil] Working directory for the process (optional)
+    # @param environment [Hash, nil] Environment variables to set (optional)
+    # @return [Integer] The process ID of the started process
+    # @raise [StandardError] If the process fails to start
+    def self.run_background(command, pid_file, working_dir: nil, environment: {})
+      # Ensure the command is not nil or empty
+      raise ArgumentError, "Command cannot be nil or empty" if command.nil? || command.strip.empty?
+      raise ArgumentError, "PID file path cannot be nil or empty" if pid_file.nil? || pid_file.strip.empty?
+
+      # Convert command to array for Process.spawn
+      cmd_array = if Makit::Environment.is_windows?
+          # Windows: Use cmd /c for complex commands
+          ["cmd", "/c", command]
+        else
+          # Unix-like: Use shell for command parsing
+          ["sh", "-c", command]
+        end
+
+      # Prepare spawn options
+      spawn_options = {}
+      spawn_options[:chdir] = working_dir if working_dir
+      spawn_options[:pgroup] = true unless Makit::Environment.is_windows?
+
+      # Set environment variables
+      env = ENV.to_h.merge(environment)
+      spawn_options[:unsetenv_others] = false
+
+      begin
+        # Start the process
+        pid = Process.spawn(env, *cmd_array, spawn_options)
+        
+        # Write PID to file
+        File.write(pid_file, pid.to_s)
+        
+        # Give the process a moment to start
+        sleep(0.5)
+        
+        # Verify the process is still running
+        begin
+          Process.getpgid(pid) if Makit::Environment.is_windows?
+          Process.getpgid(pid) unless Makit::Environment.is_windows?
+        rescue Errno::ESRCH
+          raise StandardError, "Process failed to start or exited immediately"
+        end
+
+        pid
+      rescue => e
+        # Clean up PID file if process failed to start
+        File.delete(pid_file) if File.exist?(pid_file)
+        raise StandardError, "Failed to start background process: #{e.message}"
+      end
+    end
+
+    # Stop a background process using its PID file
+    #
+    # This method reads the PID from a file and terminates the process gracefully.
+    # It handles cross-platform differences in process termination.
+    #
+    # @param pid_file [String] Path to the PID file containing the process ID
+    # @param signal [String] Signal to send (default: "TERM" for graceful shutdown)
+    # @return [Boolean] True if the process was stopped, false if it wasn't running
+    def self.stop_background(pid_file, signal: "TERM")
+      return false unless File.exist?(pid_file)
+
+      begin
+        pid = File.read(pid_file).strip.to_i
+        return false if pid <= 0
+
+        # Check if process is still running
+        begin
+          if Makit::Environment.is_windows?
+            # Windows: Use taskkill
+            if signal == "TERM"
+              system("taskkill /PID #{pid} /F >nul 2>&1")
+            else
+              system("taskkill /PID #{pid} /F >nul 2>&1")
+            end
+          else
+            # Unix-like: Use kill with specified signal
+            Process.kill(signal, pid)
+          end
+          
+          # Wait a moment for the process to terminate
+          sleep(0.5)
+          
+          # Verify the process is gone
+          begin
+            Process.getpgid(pid)
+            # Process still running, force kill if TERM didn't work
+            if signal == "TERM"
+              return stop_background(pid_file, signal: "KILL")
+            end
+            return false
+          rescue Errno::ESRCH
+            # Process is gone, success
+            true
+          end
+        rescue Errno::ESRCH, Errno::EPERM
+          # Process was not running or permission denied
+          false
+        end
+      rescue => e
+        # Log error but don't raise
+        puts "Error stopping background process: #{e.message}" if defined?(puts)
+        false
+      ensure
+        # Clean up PID file
+        File.delete(pid_file) if File.exist?(pid_file)
+      end
+    end
+
+    # Check if a background process is still running using its PID file
+    #
+    # @param pid_file [String] Path to the PID file containing the process ID
+    # @return [Boolean] True if the process is running, false otherwise
+    def self.background_running?(pid_file)
+      return false unless File.exist?(pid_file)
+
+      begin
+        pid = File.read(pid_file).strip.to_i
+        return false if pid <= 0
+
+        # Check if process is still running
+        Process.getpgid(pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      rescue => e
+        # Log error but return false
+        puts "Error checking background process: #{e.message}" if defined?(puts)
+        false
+      end
+    end
+
+    # Get the PID of a background process from its PID file
+    #
+    # @param pid_file [String] Path to the PID file containing the process ID
+    # @return [Integer, nil] The process ID, or nil if not found or invalid
+    def self.get_background_pid(pid_file)
+      return nil unless File.exist?(pid_file)
+
+      begin
+        pid = File.read(pid_file).strip.to_i
+        return nil if pid <= 0
+        pid
+      rescue => e
+        puts "Error reading PID file: #{e.message}" if defined?(puts)
+        nil
+      end
+    end
+
+    # Clean up stale PID files (processes that are no longer running)
+    #
+    # @param pid_files [Array<String>] Array of PID file paths to check
+    # @return [Array<String>] Array of cleaned up PID file paths
+    def self.cleanup_stale_pids(pid_files)
+      cleaned = []
+      
+      pid_files.each do |pid_file|
+        next unless File.exist?(pid_file)
+        
+        unless background_running?(pid_file)
+          File.delete(pid_file)
+          cleaned << pid_file
+        end
+      end
+      
+      cleaned
+    end
+
+    # Health check for a service running on a specific port
+    #
+    # @param port [Integer] Port number to check
+    # @param host [String] Host to check (default: "localhost")
+    # @param timeout [Integer] Timeout in seconds (default: 5)
+    # @return [Boolean] True if the service is responding, false otherwise
+    def self.health_check_port(port, host: "localhost", timeout: 5)
+      require 'net/http'
+      require 'timeout'
+      
+      begin
+        uri = URI("http://#{host}:#{port}")
+        Timeout.timeout(timeout) do
+          response = Net::HTTP.get_response(uri)
+          response.code.to_i < 500 # Consider 4xx as "responding" but 5xx as "unhealthy"
+        end
+      rescue => e
+        false
+      end
+    end
+
+    # Health check for multiple ports
+    #
+    # @param ports [Array<Integer>] Array of port numbers to check
+    # @param host [String] Host to check (default: "localhost")
+    # @param timeout [Integer] Timeout in seconds (default: 5)
+    # @return [Hash] Hash with port numbers as keys and health status as values
+    def self.health_check_ports(ports, host: "localhost", timeout: 5)
+      results = {}
+      
+      ports.each do |port|
+        results[port] = health_check_port(port, host: host, timeout: timeout)
+      end
+      
+      results
+    end
   end
 end

data/lib/makit/protoc.rb

@@ -98,7 +98,12 @@ module Makit
             FileUtils.mkdir_p(output_dir.to_s)
             "protoc --csharp_out=#{output_dir} #{proto}".run
           else
-            "protoc --#{language}_out=#{output_relative_path} #{proto}".run
+            # Use grpc_tools_ruby_protoc for Ruby to generate compatible code
+            if language == "ruby"
+              "grpc_tools_ruby_protoc --ruby_out=#{output_relative_path} --grpc_out=#{output_relative_path} #{proto}".run
+            else
+              "protoc --#{language}_out=#{output_relative_path} #{proto}".run
+            end
           end
         end
       end