unipod 0.1.0

data/lib/unipod/server/download_handler.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'digest'
+require 'thread'
+
+module UniPod
+  module Server
+    # 处理包下载的处理程序
+    class DownloadHandler
+      attr_reader :cache_manager, :verbose
+      
+      # 使用类变量存储包构建锁，便于在不同处理程序间共享
+      @@package_build_locks = {}
+      @@locks_mutex = Mutex.new
+      
+      # 获取共享的包构建锁表
+      def self.package_build_locks
+        @@package_build_locks
+      end
+      
+      # 获取共享的锁互斥量
+      def self.locks_mutex
+        @@locks_mutex
+      end
+      
+      def initialize(cache_manager, options = {})
+        @cache_manager = cache_manager
+        @verbose = options[:verbose] || false
+      end
+      
+      # 添加CORS头信息
+      def add_cors_headers(res)
+        res['Access-Control-Allow-Origin'] = '*'
+        res['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
+        res['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, Accept, X-Requested-With'
+        res['Access-Control-Max-Age'] = '86400' # 24小时
+        
+        # 添加npm兼容的header
+        res['npm-notice'] = 'UniPod Registry for Unity Package Manager'
+        
+        # Unity Package Manager 专用头
+        res['X-Unity-Package-Manager'] = 'true'
+        
+        # 添加CORS头，确保Unity Package Manager可以正确识别
+        res['Access-Control-Expose-Headers'] = 'Content-Type, ETag, Cache-Control, Content-Length, Accept-Ranges, X-Unity-Package-Manager'
+        
+        # 添加缓存控制头
+        res['Cache-Control'] = 'max-age=0, no-cache, no-store, must-revalidate'
+        res['Pragma'] = 'no-cache'
+        res['Expires'] = '0'
+      end
+
+      # 处理包下载请求 - Unity Package Manager API
+      def handle_package_download(package_name, tarball_name, res, req_id = 0, req = nil)
+        log_verbose "[#{req_id}] 处理包下载请求: #{package_name} - #{tarball_name}"
+        
+        # 添加CORS头，确保跨域请求正常工作
+        add_cors_headers(res)
+        
+        # 从tarball名称中提取版本
+        version_match = tarball_name.match(/#{Regexp.escape(package_name)}-(.+)\.tgz/)
+        version = version_match ? version_match[1] : '1.0.0'
+        
+        # 处理HEAD请求 - Unity Package Manager会先发送HEAD请求检查包是否存在
+        if req && req.request_method == 'HEAD'
+          handle_head_request(package_name, tarball_name, version, res, req_id)
+          return
+        end
+        
+        # 处理GET请求 - 下载tarball文件
+        handle_get_request(package_name, tarball_name, res, req_id)
+      end
+      
+      private
+      
+      # 处理HEAD请求
+      def handle_head_request(package_name, tarball_name, version, res, req_id)
+        log_verbose "[#{req_id}] 处理HEAD请求: #{package_name} - #{tarball_name} (版本: #{version})"
+        
+        # 检查tarball是否存在于缓存中
+        tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+        
+        if tarball_path && File.exist?(tarball_path)
+          serve_tarball_head(tarball_path, tarball_name, res, req_id)
+        else
+          # 找不到tarball，尝试动态生成
+          log_verbose "[#{req_id}] HEAD请求: 未找到包 #{package_name} 的tarball: #{tarball_name}，尝试生成"
+          
+          # 获取当前包的锁或创建一个新锁
+          package_lock = get_package_lock("#{package_name}-#{version}")
+          
+          # 使用锁确保只有一个线程在生成tarball
+          package_lock.synchronize do
+            # 再次检查文件是否存在（可能在我们获取锁的同时被其他线程创建）
+            tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+            if tarball_path && File.exist?(tarball_path)
+              serve_tarball_head(tarball_path, tarball_name, res, req_id)
+              return
+            end
+            
+            # 尝试构建tarball
+            if try_build_package_tarball(package_name, version, tarball_name, req_id)
+              # 再次检查文件是否生成
+              tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+              if tarball_path && File.exist?(tarball_path)
+                serve_tarball_head(tarball_path, tarball_name, res, req_id)
+                return
+              end
+            end
+          end
+          
+          # 如果仍然无法生成tarball，返回404
+          log_verbose "[#{req_id}] HEAD请求: 无法找到或生成包 #{package_name} 的tarball: #{tarball_name}"
+          res.status = 404
+          res['Content-Type'] = 'application/json'
+        end
+      end
+      
+      # 处理HEAD请求的tarball文件头信息
+      def serve_tarball_head(tarball_path, tarball_name, res, req_id)
+        file_size = File.size(tarball_path)
+        
+        # 计算shasum以确保与包信息API中的值匹配
+        file_content = File.open(tarball_path, 'rb') { |f| f.read }
+        shasum = Digest::SHA1.hexdigest(file_content)
+        log_verbose "[#{req_id}] HEAD请求: 文件shasum: #{shasum}"
+        
+        res.status = 200
+        res['Content-Type'] = 'application/octet-stream'
+        res['Content-Disposition'] = "attachment; filename=#{tarball_name}"
+        res['Content-Length'] = file_size.to_s
+        
+        # 添加ETag头，这对Unity Package Manager也很重要
+        res['ETag'] = %Q{"#{shasum}"}
+      end
+      
+      # 处理GET请求
+      def handle_get_request(package_name, tarball_name, res, req_id)
+        # 尝试从缓存中查找
+        tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+        
+        if tarball_path && File.exist?(tarball_path)
+          # 文件已存在，直接返回
+          return serve_existing_tarball(tarball_path, tarball_name, res, req_id)
+        else
+          # 尝试从包信息动态生成tarball
+          log_verbose "[#{req_id}] 未找到tarball，尝试动态生成: #{package_name} - #{tarball_name}"
+          
+          # 从tarball名称中提取版本
+          version_match = tarball_name.match(/#{Regexp.escape(package_name.gsub('/', '-'))}-(.+)\.tgz/)
+          version = version_match ? version_match[1] : nil
+          
+          if version
+            # 获取当前包的锁或创建一个新锁
+            package_lock = get_package_lock("#{package_name}-#{version}")
+            
+            # 使用锁确保只有一个线程在生成tarball
+            package_lock.synchronize do
+              # 再次检查文件是否存在（可能在我们获取锁的同时被其他线程创建）
+              tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+              if tarball_path && File.exist?(tarball_path)
+                return serve_existing_tarball(tarball_path, tarball_name, res, req_id)
+              end
+              
+              # 尝试构建tarball文件
+              if try_build_package_tarball(package_name, version, tarball_name, req_id)
+                # 检查是否生成了tarball
+                tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+                if tarball_path && File.exist?(tarball_path)
+                  return serve_existing_tarball(tarball_path, tarball_name, res, req_id)
+                end
+              end
+            end
+          end
+          
+          # 如果动态生成失败，返回404
+          log_verbose "[#{req_id}] 动态生成tarball失败，返回404"
+          handle_file_not_found(package_name, tarball_name, res, req_id)
+        end
+      end
+      
+      # 返回已存在的tarball文件
+      def serve_existing_tarball(tarball_path, tarball_name, res, req_id)
+        log_verbose "[#{req_id}] 找到tarball: #{tarball_path}, 大小: #{File.size(tarball_path)}"
+        
+        begin
+          file_size = File.size(tarball_path)
+          file_content = File.open(tarball_path, 'rb') { |f| f.read }
+          
+          # 计算shasum以确保与包信息API中的值匹配
+          shasum = Digest::SHA1.hexdigest(file_content)
+          log_verbose "[#{req_id}] 文件shasum: #{shasum}"
+          
+          res.status = 200
+          res['Content-Type'] = 'application/octet-stream'
+          res['Content-Disposition'] = "attachment; filename=#{tarball_name}"
+          res['Content-Length'] = file_size.to_s
+          
+          # 设置ETag和其他下载相关头
+          res['ETag'] = %Q{"#{shasum}"}
+          res['Accept-Ranges'] = 'bytes'
+          
+          # 使用字符串形式返回文件内容，避免流式传输的问题
+          res.body = file_content
+          
+          log_verbose "[#{req_id}] 成功返回tarball: #{tarball_path}, 大小: #{file_size}"
+          true
+        rescue => e
+          handle_file_read_error(e, res, req_id)
+          false
+        end
+      end
+      
+      # 尝试构建包的tarball文件（不返回响应，仅用于生成文件）
+      def try_build_package_tarball(package_name, version, tarball_name, req_id)
+        # 仅获取这个版本的包信息，避免加载所有版本
+        package_info = nil
+        latest_version = nil
+        is_latest_version = false
+        
+        # 尝试从索引中定位特定版本的包信息
+        if @cache_manager.respond_to?(:get_package_versions)
+          package_versions = @cache_manager.get_package_versions(package_name)
+          if package_versions && package_versions['versions'] && package_versions['versions'][version]
+            package_info = package_versions['versions'][version]
+            # 检查是否为最新版本
+            if package_versions['dist-tags'] && package_versions['dist-tags']['latest']
+              latest_version = package_versions['dist-tags']['latest']
+              is_latest_version = (version == latest_version)
+            end
+          end
+        end
+        
+        # 如果找不到特定版本，使用通用包信息
+        if !package_info && @cache_manager.respond_to?(:get_package_info)
+          package_info = @cache_manager.get_package_info(package_name)
+          if package_info && package_info['version']
+            latest_version = package_info['version']
+            is_latest_version = (version == latest_version)
+          end
+        end
+        
+        # 从Git信息中获取克隆所需的信息
+        if package_info && package_info['git'] && package_info['git']['url']
+          git_url = package_info['git']['url']
+          
+          # 确定Git标签或分支
+          git_tag = nil
+          git_branch = nil
+          
+          # 首先检查是否有特定版本的标签
+          if package_info['versions'] && package_info['versions'][version] && 
+             package_info['versions'][version]['git'] && package_info['versions'][version]['git']['tag']
+            git_tag = package_info['versions'][version]['git']['tag']
+          elsif package_info['git']['tag']
+            git_tag = package_info['git']['tag']
+          else
+            # 否则使用版本号作为标签（常规约定）
+            git_tag = "v#{version}"
+          end
+          
+          # 作为后备，使用分支
+          git_branch = package_info['git']['branch'] || 'main'
+          
+          log_verbose "[#{req_id}] 将包构建任务添加到队列: #{package_name}@#{version} (#{git_url})"
+          
+          # 获取包构建队列单例实例
+          builder_queue = PackageBuilderQueue.instance
+          
+          # 设置任务优先级
+          # 下载请求的任务优先级为1（较高），由包信息API触发的构建优先级为0（普通）
+          priority = 1  # 下载请求优先级高
+          
+          # 将任务添加到队列
+          builder_queue.enqueue(package_name, version, git_url, git_tag, git_branch, priority) do |success, tarball_path|
+            if success
+              log_verbose "[#{req_id}] 异步包构建成功: #{tarball_path}"
+            else
+              log_verbose "[#{req_id}] 异步包构建失败: #{package_name}@#{version}"
+            end
+          end
+          
+          # 检查任务是否已经完成（如果已有文件）
+          tarball_path = @cache_manager.get_package_tarball(package_name, tarball_name)
+          if tarball_path && File.exist?(tarball_path)
+            log_verbose "[#{req_id}] 发现tarball文件已构建: #{tarball_path}"
+            return true
+          end
+          
+          # 返回 false，因为文件尚未构建完成
+          # 文件将在后台异步构建，下次请求时可能已经可用
+          log_verbose "[#{req_id}] 任务已加入队列，但尚未构建完成: #{package_name}@#{version}"
+          return false
+        else
+          log_verbose "[#{req_id}] 包信息中没有Git URL，无法构建: #{package_name}@#{version}"
+        end
+        
+        false # 生成失败
+      end
+      
+      # 获取包锁
+      def get_package_lock(package_key)
+        self.class.locks_mutex.synchronize do
+          self.class.package_build_locks[package_key] ||= Mutex.new
+        end
+      end
+      
+      # 处理文件读取错误
+      def handle_file_read_error(error, res, req_id)
+        UI.error "[#{req_id}] 读取tarball文件时出错: #{error.message}"
+        res.status = 500
+        res['Content-Type'] = 'application/json'
+        res.body = JSON.generate({
+          error: "Internal Server Error",
+          code: "FILE_READ_ERROR",
+          message: "读取文件时出错: #{error.message}"
+        })
+      end
+      
+      # 处理文件未找到
+      def handle_file_not_found(package_name, tarball_name, res, req_id)
+        log_verbose "[#{req_id}] 未找到包 #{package_name} 的tarball: #{tarball_name}"
+        res.status = 404
+        res['Content-Type'] = 'application/json'
+        json_response = JSON.generate({ 
+          error: "Not Found",
+          code: "TARBALL_NOT_FOUND", 
+          package: package_name, 
+          tarball: tarball_name,
+          message: "无法找到请求的包文件"
+        })
+        res.body = json_response
+        puts_formatted_json(json_response, req_id, "包文件未找到响应") if @verbose
+      end
+      
+      # 美化JSON并打印输出
+      def puts_formatted_json(json_string, req_id, desc = "JSON响应")
+        begin
+          # 解析JSON字符串为Ruby对象
+          json_obj = JSON.parse(json_string)
+          # 使用pretty_generate重新生成格式化的JSON
+          formatted_json = JSON.pretty_generate(json_obj)
+          # 打印格式化后的JSON
+          puts "[#{req_id}] #{desc}:"
+          puts formatted_json
+        rescue => e
+          puts "[#{req_id}] 无法格式化JSON: #{e.message}"
+          puts json_string
+        end
+      end
+      
+      def log_verbose(message)
+        UI.puts message if @verbose
+      end
+    end
+  end
+end