unipod 0.1.0

data/lib/unipod/server/package_builder_queue.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'singleton'
+
+module UniPod
+  module Server
+    # 管理包构建任务的队列，使用后台线程异步处理Git克隆和tarball构建
+    class PackageBuilderQueue
+      include Singleton
+      
+      # 表示要构建的包任务
+      class BuildTask
+        attr_reader :package_name, :version, :git_url, :git_tag, :git_branch, :priority, :created_at, :callbacks
+        
+        def initialize(package_name, version, git_url, git_tag = nil, git_branch = nil, priority = 0)
+          @package_name = package_name
+          @version = version
+          @git_url = git_url
+          @git_tag = git_tag || "v#{version}"
+          @git_branch = git_branch || 'main'
+          @priority = priority # 优先级：0=普通，1=高优先级（当前请求的包）
+          @created_at = Time.now
+          @callbacks = []
+        end
+        
+        # 添加任务完成后的回调函数
+        def add_callback(&block)
+          @callbacks << block if block_given?
+        end
+        
+        # 执行所有回调
+        def execute_callbacks(success, tarball_path = nil)
+          @callbacks.each do |callback|
+            begin
+              callback.call(success, tarball_path)
+            rescue => e
+              # 忽略回调中的错误，避免影响队列处理
+              UI.error "执行包构建回调时出错: #{e.message}" if verbose?
+            end
+          end
+        end
+        
+        # 生成任务的唯一键
+        def key
+          "#{@package_name}-#{@version}"
+        end
+        
+        # 任务已等待时间（秒）
+        def wait_time
+          Time.now - @created_at
+        end
+        
+        # 打印任务信息
+        def to_s
+          "BuildTask[#{@package_name}@#{@version}, git:#{@git_url}, tag:#{@git_tag}, priority:#{@priority}]"
+        end
+      end
+      
+      def initialize
+        @queue = Queue.new
+        @running_tasks = {}
+        @tasks_mutex = Mutex.new
+        @worker_thread = nil
+        @shutdown = false
+        @cache_manager = nil
+        @verbose = false
+      end
+      
+      # 启动工作线程
+      def start(cache_manager, options = {})
+        @cache_manager = cache_manager
+        @verbose = options[:verbose] || false
+        
+        log_verbose "启动包构建队列工作线程..."
+        
+        # 确保只启动一个工作线程
+        return if @worker_thread && @worker_thread.alive?
+        
+        @shutdown = false
+        @worker_thread = Thread.new do
+          worker_loop
+        end
+      end
+      
+      # 停止工作线程
+      def stop
+        log_verbose "正在停止包构建队列..."
+        @shutdown = true
+        @queue.clear
+        
+        # 向队列发送关闭信号（nil任务）
+        @queue << nil
+        
+        # 等待工作线程结束
+        if @worker_thread
+          begin
+            @worker_thread.join(5) # 最多等待5秒
+          rescue => e
+            log_verbose "等待工作线程结束时出错: #{e.message}"
+          end
+          
+          # 如果线程仍在运行，强制终止
+          if @worker_thread.alive?
+            log_verbose "工作线程未及时结束，强制终止"
+            @worker_thread.kill
+          end
+          
+          @worker_thread = nil
+        end
+        
+        log_verbose "包构建队列已停止"
+      end
+      
+      # 添加包构建任务到队列
+      # 如果同一个包版本已有任务，则不重复添加
+      def enqueue(package_name, version, git_url, git_tag = nil, git_branch = nil, priority = 0, &callback)
+        task = BuildTask.new(package_name, version, git_url, git_tag, git_branch, priority)
+        task.add_callback(&callback) if block_given?
+        
+        @tasks_mutex.synchronize do
+          # 检查是否已有相同的任务正在运行
+          if @running_tasks[task.key]
+            existing_task = @running_tasks[task.key]
+            existing_task.add_callback(&callback) if block_given?
+            log_verbose "跳过已在处理的任务: #{task}"
+            return false
+          end
+          
+          # 检查队列中是否已有相同的任务
+          existing_task = nil
+          @queue.size.times do
+            t = @queue.pop
+            if t && t.key == task.key
+              existing_task = t
+              # 如果新任务优先级更高，使用新任务
+              if priority > t.priority
+                log_verbose "用更高优先级的任务替换队列中的任务: #{task}"
+                t.add_callback(&callback) if block_given?
+                @queue << task
+              else
+                t.add_callback(&callback) if block_given?
+                @queue << t
+              end
+            else
+              @queue << t if t # 放回其他任务
+            end
+          end
+          
+          # 如果队列中没有相同任务，添加新任务
+          if existing_task.nil?
+            log_verbose "添加新的包构建任务到队列: #{task}"
+            @queue << task
+          end
+        end
+        
+        true
+      end
+      
+      # 获取队列中的任务数量
+      def queue_size
+        @queue.size
+      end
+      
+      # 获取当前正在处理的任务数量
+      def running_task_count
+        @tasks_mutex.synchronize { @running_tasks.size }
+      end
+      
+      private
+      
+      # 工作线程主循环
+      def worker_loop
+        log_verbose "包构建工作线程已启动"
+        
+        while !@shutdown
+          begin
+            # 从队列获取任务
+            task = @queue.pop
+            break if @shutdown || task.nil?
+            
+            # 更新正在运行的任务列表
+            @tasks_mutex.synchronize do
+              @running_tasks[task.key] = task
+            end
+            
+            log_verbose "开始处理包构建任务: #{task}"
+            success = false
+            tarball_path = nil
+            
+            begin
+              # 执行包构建
+              if @cache_manager
+                tarball_name = "#{task.package_name}-#{task.version}.tgz"
+                
+                # 首先检查是否已存在tarball文件
+                existing_tarball = @cache_manager.get_package_tarball(task.package_name, tarball_name)
+                if existing_tarball && File.exist?(existing_tarball)
+                  log_verbose "找到已存在的tarball文件: #{existing_tarball}"
+                  success = true
+                  tarball_path = existing_tarball
+                else
+                  # 克隆并构建包
+                  log_verbose "尝试克隆并构建包: #{task.package_name}@#{task.version} (#{task.git_url})"
+                  if @cache_manager.clone_and_build_package(task.package_name, task.git_url, task.git_tag, task.git_branch)
+                    # 检查构建结果
+                    tarball_path = @cache_manager.get_package_tarball(task.package_name, tarball_name)
+                    if tarball_path && File.exist?(tarball_path)
+                      log_verbose "成功构建tarball: #{tarball_path}"
+                      success = true
+                    else
+                      log_verbose "构建过程完成，但未找到tarball文件: #{tarball_name}"
+                    end
+                  else
+                    log_verbose "包构建失败: #{task.package_name}@#{task.version}"
+                  end
+                end
+              else
+                log_verbose "未设置缓存管理器，无法构建包: #{task.package_name}@#{task.version}"
+              end
+            rescue => e
+              log_verbose "处理包构建任务时出错: #{e.message}"
+              log_verbose e.backtrace.join("\n") if @verbose
+            end
+            
+            # 执行回调
+            task.execute_callbacks(success, tarball_path)
+            
+            # 更新正在运行的任务列表
+            @tasks_mutex.synchronize do
+              @running_tasks.delete(task.key)
+            end
+            
+            log_verbose "包构建任务处理#{success ? '成功' : '失败'}: #{task}"
+            
+          rescue => e
+            # 捕获循环中的任何错误，确保工作线程不会意外终止
+            log_verbose "工作线程出错: #{e.message}"
+            log_verbose e.backtrace.join("\n") if @verbose
+          end
+        end
+        
+        log_verbose "包构建工作线程已退出"
+      end
+      
+      def log_verbose(message)
+        UI.puts message if @verbose
+      end
+      
+      def verbose?
+        @verbose
+      end
+    end
+  end
+end 

data/lib/unipod/server/server.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'json'
+require 'fileutils'
+require 'socket'
+require 'rainbow'
+require 'unipod/ui'
+require_relative 'cache_manager'
+require_relative 'server_handler'
+require_relative 'download_handler'
+require_relative 'package_builder_queue'
+
+module UniPod
+  module Server
+    class VerdaccioServer
+      attr_reader :server, :port, :host
+
+      DEFAULT_PORT = 7748
+      DEFAULT_HOST = '0.0.0.0'  # 绑定到所有IP地址
+
+      #-----------------------------------------------
+      # 初始化和服务器生命周期管理
+      #-----------------------------------------------
+
+      def initialize(options = {})
+        @port = options[:port] || DEFAULT_PORT
+        @host = options[:host] || DEFAULT_HOST
+        @verbose = options[:verbose] || false
+        @cache_manager = CacheManager.new
+        @request_count = 0  # 请求计数，用于调试
+        
+        # 初始化请求处理程序
+        @server_handler = ServerHandler.new(@cache_manager, verbose: @verbose)
+        @download_handler = DownloadHandler.new(@cache_manager, verbose: @verbose)
+        
+        # 初始化包构建队列
+        @builder_queue = PackageBuilderQueue.instance
+      end
+
+      def start
+        begin
+          # 确保正在运行的服务器已停止
+          stop_running_server(@port)
+          
+          # 打印启动信息 - 这个信息保留，因为它是服务器实际启动的指示
+          # UI.puts "启动UniPod服务器: #{@host}:#{@port}" - 不再需要，Command类已经显示
+          
+          # 创建HTTP服务器
+          create_http_server
+          
+          # 注册路由处理
+          setup_routes
+          
+          # 注册退出处理
+          register_shutdown_hooks
+          
+          # 启动包构建队列
+          @builder_queue.start(@cache_manager, verbose: @verbose)
+          
+          # 预加载包信息
+          preload_packages
+          
+          # 显示缓存目录信息 - Command类已经显示类似信息，不需要重复
+          # display_cache_directories
+          
+          # 启动服务器确认
+          UI.success "UniPod服务器已启动，地址：http://#{@host}:#{@port}"
+          UI.puts "服务器正在运行，按Ctrl+C停止..."
+          
+          # 开始服务
+          @server.start
+        rescue => e
+          UI.error "启动服务器时出错: #{e.message}"
+          UI.error e.backtrace.join("\n") if @verbose
+          raise
+        end
+      end
+
+      def stop
+        begin
+          # 停止包构建队列
+          @builder_queue.stop if @builder_queue
+          
+          # 停止HTTP服务器
+          @server.shutdown if @server
+          UI.puts "服务器已停止"
+        rescue => e
+          UI.error "停止服务器时出错: #{e.message}"
+          UI.error e.backtrace.join("\n") if @verbose
+        end
+      end
+      
+      #-----------------------------------------------
+      # 服务器设置和配置
+      #-----------------------------------------------
+      
+      private
+      
+      def create_http_server
+        @server = WEBrick::HTTPServer.new(
+          Port: @port.to_i,
+          Host: @host,
+          Logger: create_logger,
+          AccessLog: create_access_log,
+          DoNotReverseLookup: true,  # 提高性能
+          RequestTimeout: 120,       # 增加超时时间
+          MaxClients: 10             # 减少线程数以降低内存使用
+        )
+      end
+      
+      def register_shutdown_hooks
+        # 注册优雅退出的处理程序
+        [:INT, :TERM].each do |signal|
+          trap(signal) do
+            UI.puts "\n正在停止服务器..."
+            @server.shutdown 
+          end
+        end
+      end
+      
+      def create_logger
+        log_level = @verbose ? WEBrick::Log::DEBUG : WEBrick::Log::WARN
+        WEBrick::Log.new($stderr, log_level)
+      end
+
+      def create_access_log
+        @verbose ? [[$stderr, WEBrick::AccessLog::COMBINED_LOG_FORMAT]] : []
+      end
+      
+      def stop_running_server(port)
+        begin
+          # 尝试使用系统命令终止占用端口的进程
+          if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+            # Windows系统
+            system("FOR /F \"tokens=5\" %a in ('netstat -ano ^| findstr :#{port}') do taskkill /F /PID %a")
+          else
+            # Unix类系统
+            system("lsof -i:#{port} | grep -v PID | awk '{print $2}' | xargs kill -9 2>/dev/null || true")
+          end
+        rescue => e
+          # 忽略错误，继续尝试启动服务器
+          log_verbose "尝试停止现有服务器时出错: #{e.message}"
+        end
+      end
+      
+      # 预加载包信息，避免首次请求延迟
+      def preload_packages
+        Thread.new do
+          log_verbose "开始预加载包信息..."
+          @cache_manager.get_all_packages
+          log_verbose "包信息预加载完成!"
+        end
+      end
+      
+      def display_cache_directories
+        # 使用Config类获取缓存目录路径
+        require 'unipod/config'
+        cache_dir = UniPod::Config.cache_dir rescue "未设置"
+        scoped_dir = File.join(cache_dir, 'scoped') rescue "未设置"
+        packages_dir = File.join(cache_dir, 'packages') rescue "未设置"
+        tarballs_dir = File.join(cache_dir, 'tarballs') rescue "未设置"
+        
+        UI.puts "============ 缓存目录结构 ============"
+        UI.puts "UniPod缓存目录: #{cache_dir}"
+        UI.puts "索引仓库目录: #{scoped_dir}"
+        UI.puts "包Git仓库目录: #{packages_dir}"
+        UI.puts "包压缩文件目录: #{tarballs_dir}"
+      end
+      
+      #-----------------------------------------------
+      # 路由设置和请求处理 - 仅保留Unity Package Manager使用的API
+      #-----------------------------------------------
+
+      def setup_routes
+        # 主路由处理所有请求
+        @server.mount_proc('/') do |req, res|
+          handle_main_route(req, res)
+        end
+      end
+      
+      def handle_main_route(req, res)
+          # 添加请求ID
+          req_id = @request_count += 1
+          
+          # 添加CORS头
+        @server_handler.add_cors_headers(res)
+        
+        # 记录请求详情
+        log_request_details(req, req_id) if @verbose
+        
+        # 处理预检请求
+        if req.request_method == 'OPTIONS'
+          handle_options_request(res, req_id)
+          return
+        end
+        
+        # 处理请求
+        begin
+          handle_request(req, res, req_id)
+        rescue => e
+          @server_handler.handle_request_error(e, res, req_id)
+        end
+        
+        # 记录响应
+        log_verbose "[#{req_id}] 响应状态码: #{res.status}"
+        log_verbose "[#{req_id}] ==========请求结束==========\n"
+      end
+      
+      def handle_options_request(res, req_id)
+        res.status = 200
+        log_verbose "[#{req_id}] 处理OPTIONS请求"
+      end
+      
+      def log_request_details(req, req_id)
+          puts "\n[#{req_id}] ==========请求详情==========\n"
+          puts "[#{req_id}] 请求方法: #{req.request_method}"
+          puts "[#{req_id}] 请求路径: #{req.path}"
+          puts "[#{req_id}] 查询字符串: #{req.query_string}"
+          
+          # 打印请求头
+          puts "[#{req_id}] 请求头:"
+          req.header.each do |k, v|
+            puts "[#{req_id}]   #{k}: #{v.join(', ')}"
+          end
+          
+          # 打印查询参数
+          if req.query
+            puts "[#{req_id}] 解析后的查询参数:"
+            req.query.each do |k, v|
+              puts "[#{req_id}]   #{k}: #{v}"
+            end
+          end
+      end
+      
+      def handle_request(req, res, req_id = 0)
+        method = req.request_method
+        path = req.path
+        
+        query_string = req.query_string.nil? ? '' : req.query_string
+        log_verbose "[#{req_id}] #{method} #{path}#{query_string.empty? ? '' : '?' + query_string}"
+        
+        # 处理首页请求 - 提供简单的欢迎页面或API信息
+        if path == '/' && method == 'GET'
+          @server_handler.handle_root_request(res, req_id)
+          return
+        end
+        
+        # 添加CORS头
+        @server_handler.add_cors_headers(res)
+        
+        # 处理OPTIONS请求
+        if method == 'OPTIONS'
+          res.status = 200
+          return
+        end
+        
+        # 只处理GET和HEAD请求，Unity Package Manager只使用这两种方法
+        if method == 'GET' || method == 'HEAD'
+          route_get_request(req, res, req_id)
+        else
+          handle_unsupported_method(method, res, req_id)
+        end
+      end
+      
+      def route_get_request(req, res, req_id)
+        path = req.path
+        
+        log_verbose "[#{req_id}] 收到GET请求: #{path}"
+        puts "\n🔍 [#{req_id}] API请求: GET #{path}"
+        puts "📝 请求参数: #{req.query.inspect}" if req.query && !req.query.empty?
+        
+        begin
+          # 健康检查
+          if path == '/health' || path == '/healthz'
+            res.status = 200
+            res['Content-Type'] = 'application/json'
+            health_data = {
+              status: 'ok',
+              uptime: (Time.now - @start_time).to_i,
+              timestamp: Time.now.to_i
+            }
+            res.body = JSON.generate(health_data)
+            puts "✅ [#{req_id}] 健康检查响应: #{health_data.inspect}"
+            return
+          end
+          
+          # 根路径 - 显示主页
+          if path == '/' || path == '/index.html'
+            @server_handler.handle_root_request(res, req_id)
+            puts "✅ [#{req_id}] 根路径请求处理完成"
+            return
+          end
+          
+          # 确保CORS头被添加到所有响应
+          @server_handler.add_cors_headers(res)
+          
+          # 搜索API - Unity Package Manager使用
+          if path == '/-/v1/search'
+            @server_handler.handle_search(req, res, req_id)
+            begin
+              response_data = JSON.parse(res.body)
+              puts "✅ [#{req_id}] 搜索API响应:"
+              puts JSON.pretty_generate(response_data)
+            rescue => e
+              puts "❌ [#{req_id}] 无法解析搜索响应JSON: #{e.message}"
+            end
+          # 包下载 - Unity Package Manager使用
+          elsif path =~ %r{^/([^/]+)/-/(.+\.tgz)$}
+            package_name = $1
+            tarball_name = $2
+            puts "📦 [#{req_id}] 包下载请求: 包名=#{package_name}, 文件=#{tarball_name}"
+            @download_handler.handle_package_download(package_name, tarball_name, res, req_id, req)
+            if res.status == 200
+              puts "✅ [#{req_id}] 包下载成功: #{package_name}/#{tarball_name}, 大小: #{res.body.bytesize} 字节"
+            else
+              begin
+                response_data = JSON.parse(res.body)
+                puts "❌ [#{req_id}] 包下载失败: #{res.status}"
+                puts JSON.pretty_generate(response_data)
+              rescue => e
+                puts "❌ [#{req_id}] 包下载失败: #{res.status}, 响应: #{res.body}"
+              end
+            end
+          # 单个包信息 - Unity Package Manager使用
+          elsif path =~ %r{^/([^/]+)$} && !path.include?('/-/')
+            package_name = $1
+            puts "📋 [#{req_id}] 包信息请求: 包名=#{package_name}"
+            @server_handler.handle_package_info(package_name, res, req_id, req)
+            begin
+              response_data = JSON.parse(res.body)
+              puts "✅ [#{req_id}] 包信息响应:"
+              puts JSON.pretty_generate(response_data)
+            rescue => e
+              puts "❌ [#{req_id}] 无法解析包信息响应JSON: #{e.message}"
+            end
+          # 未知路径
+          else
+            log_verbose "[#{req_id}] 未知GET路径: #{path}"
+            res.status = 404
+            res['Content-Type'] = 'application/json'
+            error_message = {
+              error: "Not Found",
+              code: "UNKNOWN_ROUTE", 
+              message: "路径不存在: #{path}"
+            }
+            res.body = JSON.generate(error_message)
+            puts "❌ [#{req_id}] 未知路径响应: #{error_message.inspect}"
+          end
+        rescue => e
+          @server_handler.handle_request_error(e, res, req_id)
+        end
+      end
+      
+      def handle_unsupported_method(method, res, req_id)
+        # 不支持的HTTP方法
+        res.status = 405
+        res['Content-Type'] = 'application/json'
+        res.body = JSON.generate({ 
+          error: "不支持的请求方法",
+          message: "Unity Package Manager只使用GET和HEAD方法，服务器不支持#{method}方法" 
+        })
+        log_verbose "[#{req_id}] 不支持的请求方法: #{method}"
+      end
+      
+      # 处理未知路径，返回404错误
+      def handle_unknown_path(path, res, req_id = 0)
+        log_verbose "[#{req_id}] 处理未知路径: #{path}"
+        
+        # 返回404错误
+        res.status = 404
+        res['Content-Type'] = 'application/json'
+        @server_handler.add_cors_headers(res)
+        
+        json_response = JSON.generate({
+          'error' => 'Not Found',
+          'path' => path,
+          'message' => "请求的路径不存在。Unity Package Manager使用的API为: /-/v1/search, /[package-name], /[package-name]/-/[file.tgz]"
+        })
+        res.body = json_response
+        @server_handler.puts_formatted_json(json_response, req_id, "未知路径响应") if @verbose
+      end
+      
+      #-----------------------------------------------
+      # 工具方法
+      #-----------------------------------------------
+      
+      def log_verbose(message)
+        UI.puts message if @verbose
+      end
+    end
+  end
+end