pindo 5.4.0 → 5.5.0

data/lib/pindo/client/pgyeruploadclient.rb

@@ -1,517 +0,0 @@
-require 'uri'
-require 'json'
-require 'faraday'
-require 'securerandom'
-require 'pindo/base/aeshelper'
-require 'typhoeus'
-require 'thread'
-
-module Pindo
-
-
-  class PgyerUploadClient
-
-
-      attr_accessor :token
-
-      attr_accessor :region
-      attr_accessor :bucket_name
-
-      attr_accessor :default_url
-      attr_accessor :attach_url
-
-      attr_accessor :upload_binary_file
-      attr_accessor :file_size
-      attr_accessor :progress_bar
-
-
-      def initialize()
-
-          begin
-
-            @pgyer_token_file = File.join(File::expand_path(Pindoconfig.instance.pindo_dir), ".pgyer_token")
-            config_file = File.join(File::expand_path(Pindoconfig.instance.pindo_common_configdir), "pgyer_client_config.json")
-            config_json = JSON.parse(File.read(config_file))
-
-            @region = config_json["region"]
-            @bucket_name = config_json["bucket_name"]
-            @default_url = config_json["default_url"]
-            @attach_url = config_json["attach_url"]
-
-            @use_local_wechat_url = config_json["use_local_wechat_url"]
-            @baseurl = config_json["pgyerapps_base_url"]
-            @request_config = config_json["pgyerapps_req_config"]
-            @pgyer_aes_key = config_json["pgyerapps_aes_key"]
-
-            @token = load_token
-            
-            # 添加互斥锁用于线程安全
-            @upload_eTags_mutex = Mutex.new
-            @tasks_queue_mutex = Mutex.new
-            @active_tasks_mutex = Mutex.new
-            @upload_failed_mutex = Mutex.new  # 为上传失败状态添加互斥锁
-            @upload_failed = false
-
-          rescue => error
-              raise Informative,  "PgyerUploadClient 初始化失败！"
-          end
-
-      end
-
-      def load_token()
-          token = nil
-          if File.exist?(@pgyer_token_file)
-              begin
-                data = File.read(@pgyer_token_file)
-
-                data_string = AESHelper::aes_128_ecb_decrypt(@pgyer_aes_key, data)
-                temp_token = data_string
-                temp_token = JSON.parse(data_string)
-                if !temp_token.nil? && !temp_token["token"].nil? && !temp_token["username"].nil?
-                    token = temp_token
-                end
-              rescue => error
-                  raise Informative,  "PgyerUploadClient 加载pgyer token 失败!!!"
-              end
-          end
-          return token
-      end
-
-      def upload_file(binary_file:nil, isAttach:false)
-
-        raise Informative, "上传文件不能为空" if binary_file.nil? || !File.exist?(binary_file)
-        
-        @upload_binary_file = binary_file
-        @file_size = File.size(@upload_binary_file)
-        @progress_bar = PgyerUploadProgressBar.new(upload_total_size:@file_size)
-        @upload_failed = false  # 重置上传失败标志
-
-        extension = File.extname(@upload_binary_file)
-        filename = File.basename(@upload_binary_file)
-        size_level = 1024 * 1024
-        file_bytes = File.binread(@upload_binary_file)
-        checksum = Digest::MD5.hexdigest(file_bytes)
-        file_uuid = SecureRandom.uuid
-        total_m = sprintf("%.2f", 1.00 * @file_size / 1024 /1024 )
-
-
-        upload_path = @default_url
-        content_disposition = nil
-        if isAttach
-            upload_path = @default_url + @attach_url
-            content_disposition = "attachment; filename=#{filename}"
-        end
-
-        upload_path_key = upload_path + file_uuid + extension
-
-        task_num = 10
-
-        puts "文件路径: #{@upload_binary_file}"
-        puts "文件大小: #{total_m}M"
-        puts "上传路径: #{upload_path_key}"
-        puts
-        puts "切片大小: 5MB"
-
-        upload_result = nil
-
-        begin
-          file_size_param = 1.00 * @file_size / 1024 /1024
-          result_data = post_upload_url_req(upload_path_key:upload_path_key, file_ceil_size:file_size_param.ceil)
-          
-          if result_data.nil? || !result_data.has_key?("data") || !result_data["data"].has_key?("uploadId")
-            raise Informative, "获取上传ID失败，请检查网络或服务器状态"
-          end
-          
-          upload_id = result_data["data"]["uploadId"]
-          # 创建统一的任务队列
-          @tasks_queue = Queue.new
-          @worker_threads = []
-          upload_params_list = result_data["data"]["uploadParamsList"]
-          upload_item_num = upload_params_list.length
-          @expected_parts = upload_item_num  # 保存预期的分片数量
-          task_num = upload_item_num
-          retry_count = 5
-          
-          # 合理限制线程数
-          if task_num < 2
-            task_num = 2
-          end
-
-          if task_num > 30
-            task_num = 30
-          end
-
-          # 根据系统CPU核心数自动调整线程数
-          available_cores = Etc.respond_to?(:nprocessors) ? Etc.nprocessors : 4
-          task_num = [task_num, available_cores * 2].min
-          
-          # 设置重试次数并将所有任务加入队列
-          upload_params_list.each do |item|
-            item["retryCount"] = retry_count
-            @tasks_queue.push(item)
-          end
-
-          puts "切分个数: #{upload_item_num}"
-          puts "线程个数: #{task_num}"
-          puts "重试次数: #{retry_count}"
-          puts
-
-          Funlog.instance.fancyinfo_start("开始上传...")
-          @upload_eTags = []
-          @active_tasks = 0  # 跟踪活动任务数量
-
-          continuous_upload_data_req(concurrency:task_num)
-          
-          # 检查上传是否全部成功
-          if upload_failed? || @upload_eTags.length != @expected_parts
-              upload_result = nil
-              Funlog.instance.fancyinfo_error("文件#{@upload_binary_file} 上传失败! 😭😭😭")
-              return upload_result
-          end
-
-          result_data = post_upload_finish_req(upload_path_key:upload_path_key, upload_id:upload_id, eTags:@upload_eTags)
-
-          if result_data && result_data["code"] == 200
-              upload_result = upload_path_key
-              Funlog.instance.fancyinfo_success("文件#{@upload_binary_file} 上传成功! 😎😎😎")
-          else
-              upload_result = nil
-              error_msg = result_data && result_data["msg"] ? result_data["msg"] : "未知错误"
-              Funlog.instance.fancyinfo_error("文件#{@upload_binary_file} 上传失败: #{error_msg} 😭😭😭")
-          end
-          
-        rescue => e
-          upload_result = nil
-          Funlog.instance.fancyinfo_error("文件上传过程发生异常: #{e.message} 😭😭😭")
-        ensure
-          # 确保所有工作线程都被清理
-          cleanup_worker_threads
-        end
-
-        return upload_result
-
-      end
-
-      # 安全地检查上传失败状态
-      def upload_failed?
-        @upload_failed_mutex.synchronize { @upload_failed }
-      end
-      
-      # 安全地设置上传失败状态
-      def set_upload_failed(error_msg = nil)
-        @upload_failed_mutex.synchronize do 
-          @upload_failed = true
-          Funlog.instance.fancyinfo_error("上传失败: #{error_msg}") if error_msg
-        end
-      end
-      
-      # 清理所有工作线程
-      def cleanup_worker_threads
-        @worker_threads.each do |thread|
-          # 尝试安全终止线程
-          thread.exit if thread.alive?
-        end
-        @worker_threads.clear
-      end
-
-      def continuous_upload_data_req(concurrency:1)
-          # 初始化活动任务计数和条件变量
-          @active_tasks = 0
-          @task_complete_cv = ConditionVariable.new
-          
-          # 初始化连续上传，最多启动concurrency个并发任务
-          start_tasks = [concurrency, @tasks_queue.size].min
-          start_tasks.times { schedule_next_task }
-          
-          # 设置超时保护
-          timeout_seconds = 300  # 5分钟超时
-          start_time = Time.now
-          
-          # 等待所有任务完成
-          @tasks_queue_mutex.synchronize do
-              while (@active_tasks > 0 || !@tasks_queue.empty?) && !upload_failed?
-                  # 添加超时保护
-                  remaining_time = timeout_seconds - (Time.now - start_time)
-                  if remaining_time <= 0
-                    set_upload_failed("上传任务超时")
-                    break
-                  end
-                  
-                  # 等待任务完成通知，最多等待30秒
-                  @task_complete_cv.wait(@tasks_queue_mutex, [remaining_time, 30].min)
-              end
-          end
-          
-          # 检查所有分片是否都上传成功
-          if @upload_eTags.length != @expected_parts && !upload_failed?
-              set_upload_failed("部分分片上传失败，已上传#{@upload_eTags.length}/#{@expected_parts}")
-          end
-      end
-      
-      def schedule_next_task
-          # 检查是否应该停止调度
-          return if upload_failed?
-          
-          # 尝试从队列中获取下一个任务
-          @tasks_queue_mutex.synchronize do
-              unless @tasks_queue.empty?
-                  upload_params_item = @tasks_queue.pop
-                  @active_tasks_mutex.synchronize { @active_tasks += 1 }
-                  
-                  # 异步处理任务，不阻塞主线程
-                  worker_thread = Thread.new do
-                      begin
-                          process_upload_task(upload_params_item)
-                      rescue => e
-                          # 捕获并记录任务处理过程中的异常
-                          set_upload_failed("处理分片#{upload_params_item["partNo"]}时出错: #{e.message}")
-                      ensure
-                          # 任务完成后，减少活动任务计数并通知等待线程
-                          @active_tasks_mutex.synchronize { @active_tasks -= 1 }
-                          
-                          # 如果队列不为空，调度下一个任务
-                          schedule_next_task if !upload_failed?
-                          
-                          # 通知等待线程任务已完成
-                          @tasks_queue_mutex.synchronize { @task_complete_cv.broadcast }
-                      end
-                  end
-                  
-                  # 保存线程引用以便后续清理
-                  @worker_threads << worker_thread
-              end
-          end
-      end
-      
-      def process_upload_task(upload_params_item)
-          upload_url = upload_params_item["signedUrl"]
-          part_no = upload_params_item["partNo"]
-          
-          file_size_ele = 1024 * 1024 * 5  #5M
-          start_position = file_size_ele * (part_no - 1)
-          if part_no * file_size_ele > @file_size
-              read_length = @file_size - start_position
-          else
-              read_length = file_size_ele
-          end
-          
-          file = File.open(@upload_binary_file, "rb")
-          begin
-              file.seek(start_position)
-              put_data = file.read(read_length)
-              
-              request = create_req(upload_url:upload_url, body_data:put_data, read_length:read_length)
-              
-              # 设置上传进度回调
-              upload_size_last = 0
-              request.on_progress do |dltotal, dlnow, ultotal, ulnow|
-                  if ulnow && ulnow > upload_size_last
-                      upload_size_last = ulnow
-                      @progress_bar.update_upload_index(upload_part:part_no, upload_size:ulnow)
-                      @progress_bar.update_upload_progress()
-                  end
-              end
-              
-              # 设置请求超时
-              request.options[:timeout] = 300  # 5分钟超时
-              
-              # 执行请求并等待完成
-              response = request.run
-              
-              # 处理响应结果
-              if response.success?
-                  @progress_bar.complete_upload_index(upload_part:part_no, complete_size:read_length)
-                  etag = response.headers["ETag"]
-                  if etag.nil? || etag.empty?
-                    raise "服务器返回的ETag为空"
-                  end
-                  eTag_item = { partNumber: part_no, tag: etag}
-                  @upload_eTags_mutex.synchronize { @upload_eTags << eTag_item }
-              else
-                  @progress_bar.delete_upload_index(upload_part:part_no)
-                  upload_params_item["retryCount"] = upload_params_item["retryCount"] - 1
-                  if upload_params_item["retryCount"] > 0
-                      # 重试任务
-                      @tasks_queue_mutex.synchronize { @tasks_queue.push(upload_params_item) }
-                  else
-                      set_upload_failed("文件#{@upload_binary_file} 分片#{part_no}上传失败: HTTP #{response.code}")
-                  end
-              end
-          ensure
-              file.close
-          end
-      end
-
-      def create_req(upload_url:nil, body_data:nil, read_length:nil)
-
-          request = nil
-          proxy_options = {
-            proxy: ENV['http_proxy'] || ENV['https_proxy'],
-            proxyuserpwd: "#{ENV['HTTP_PROXY_USER']}:#{ENV['HTTP_PROXY_PASSWORD']}"
-          }
-
-          if proxy_options[:proxy]
-            request = Typhoeus::Request.new(
-              upload_url,
-              method: :put,
-              proxy: proxy_options[:proxy],
-              proxyuserpwd: proxy_options[:proxyuserpwd],
-              :body => body_data,
-              :headers => {
-                'Content-Type' => 'application/octet-stream',
-                'token' => @token['token'],
-                'Content-Length' => read_length.to_s
-              }
-            )
-          else
-            request = Typhoeus::Request.new(
-              upload_url,
-              method: :put,
-              :body => body_data,
-              :headers => {
-                'Content-Type' => 'application/octet-stream',
-                'token' => @token['token'],
-                'Content-Length' => read_length.to_s
-              }
-            )
-
-          end
-          return request
-      end
-
-      def post_upload_finish_req(upload_path_key:nil, upload_id:nil, eTags:nil)
-
-          boss_url = @baseurl + @request_config["multi_signed_url_upload"]
-
-          body_params = {
-              functionName:"finish",
-              fileKey:upload_path_key,
-              uploadId:upload_id,
-              tags:eTags
-          }
-
-          begin
-            con = HttpClient.create_instance_with_proxy
-            res = con.post do |req|
-                req.url boss_url
-                req.headers['Content-Type'] = 'application/json'
-                req.headers['token'] = @token["token"]
-                req.body = body_params.to_json
-                req.options.timeout = 120  # 设置2分钟超时
-            end
-
-            result_data = nil
-            if !res.body.nil?
-                result_data = JSON.parse(res.body)
-            end
-
-            return result_data
-          rescue => e
-            Funlog.instance.fancyinfo_error("完成上传请求失败: #{e.message}")
-            return nil
-          end
-      end
-
-
-      def post_upload_url_req(upload_path_key:nil, file_ceil_size:nil)
-
-          boss_url = @baseurl + @request_config["multi_signed_url_upload"]
-
-          body_params = {
-              functionName:"start",
-              fileKey:upload_path_key,
-              fileSize:file_ceil_size
-          }
-
-          begin
-            con = HttpClient.create_instance_with_proxy
-            res = con.post do |req|
-                req.url boss_url
-                req.headers['Content-Type'] = 'application/json'
-                req.headers['token'] = @token["token"]
-                req.body = body_params.to_json
-                req.options.timeout = 60  # 设置1分钟超时
-            end
-
-            result_data = nil
-            if !res.body.nil?
-                result_data = JSON.parse(res.body)
-            end
-
-            return result_data
-          rescue => e
-            Funlog.instance.fancyinfo_error("获取上传URL失败: #{e.message}")
-            return nil
-          end
-      end
-
-      class PgyerUploadProgressBar
-
-        attr_accessor :draw_char
-        attr_accessor :complete_size
-        attr_accessor :upload_total_size
-        attr_accessor :last_update_time
-        attr_accessor :update_ing_size
-        attr_accessor :is_done
-
-        def initialize(upload_total_size:nil, draw_char:'>')
-          @upload_total_size = upload_total_size
-          @draw_char = draw_char
-          @last_update_time = (Time.now.to_f * 1000).to_i #毫秒
-
-          @complete_size = 0
-          @update_ing_size = {}
-          @is_done = false
-          
-          # 添加互斥锁来保护进度条更新
-          @mutex = Mutex.new
-        end
-
-        def update_upload_index(upload_part:nil, upload_size:nil)
-            @mutex.synchronize do
-                @update_ing_size[upload_part] = upload_size
-            end
-        end
-
-        def delete_upload_index(upload_part:nil)
-            @mutex.synchronize do
-                @update_ing_size[upload_part] = 0
-            end
-        end
-
-        def complete_upload_index(upload_part:nil, complete_size:nil)
-            @mutex.synchronize do
-                @complete_size = @complete_size + complete_size
-                @update_ing_size[upload_part] = 0
-            end
-        end
-
-        def update_upload_progress()
-            time_now = (Time.now.to_f * 1000).to_i #毫秒
-            if time_now - @last_update_time > 80
-                @mutex.synchronize do
-                    @last_update_time = time_now
-                    total_num = @upload_total_size
-                    index_num = @complete_size
-                    @update_ing_size.each do |key, value|
-                       index_num = index_num + value
-                    end
-
-                    progress_str = sprintf("%.2f", 100.0 * index_num / total_num )
-                    total_size = sprintf("%.2f", 1.00 * total_num / 1024 /1024 )
-                    upload_size = sprintf("%.2f", 1.00 * index_num / 1024 /1024 )
-                    index = 40.0 * index_num / total_num
-                    upload_message = "已上传:#{upload_size}MB|#{progress_str}\%【" + (@draw_char * (index/1).floor).ljust(40.0, '_') +  "】Total:#{total_size}MB"
-                    Funlog.instance.fancyinfo_update(upload_message)
-                    if index_num == total_num && !@is_done
-                      @is_done = true
-                      Funlog.instance.fancyinfo_success(upload_message)
-                    end
-                end
-            end
-        end
-
-      end
-
-  end
-end

data/lib/pindo/command/pgyer.rb

@@ -1,18 +0,0 @@
-
-require 'pindo/command/pgyer/login'
-require 'pindo/command/pgyer/upload'
-require 'pindo/command/pgyer/download'
-require 'pindo/command/pgyer/comment'
-require 'pindo/command/pgyer/apptest'
-require 'pindo/command/pgyer/resign'
-
-module Pindo
-  class Command
-    
-    class Pgyer < Command
-      self.abstract_command = true
-      self.summary = 'pgyer网站的相关命令'
-    end
-
-  end
-end