tes-request 0.1

data/lib/tes/request/expression.rb

@@ -0,0 +1,116 @@
+module Tes
+  module Request
+    class Expression
+      include Comparable
+
+      REG_EXP_CHAIN = /^(!)?([0-9A-Za-z_.]+)(\?|=|>=|<=|<|>)?(-?[\w]+(\.[\d]+)?)?/
+
+      # @param [String] exp_str 表达式字符串
+      def initialize(exp_str)
+        mt = exp_str.match(REG_EXP_CHAIN)
+        raise(ArgumentError, "非法的表达式片段:\t#{exp_str}") unless mt
+
+        @data = {}
+        @data[:revert] = true if mt[1]
+        @data[:left_exp] = mt[2]
+        if mt[3]
+          @data[:op] = mt[3]
+          if mt[4]
+            @data[:expect_val] = mt[4]
+            if @data[:expect_val] =~ /^-?\d+(\.[\d]+)?/
+              @data[:expect_val] = mt[5] ? @data[:expect_val].to_f : @data[:expect_val].to_i
+            end
+          end
+        end
+      end
+
+      attr_reader :data
+
+      # 计算数据是否满足表达式(深度解析后)
+      # @param [Object] data
+      # @return [true,false]
+      def match?(data)
+        op = @data[:op]
+        unless data.respond_to?(:get_by_chain)
+          raise(ArgumentError, 'data arg should be respond to :get_by_chain')
+        else
+          ret = if !op
+                  data.get_by_chain @data[:left_exp]
+                elsif op == '?'
+                  chain_data = data.get_by_chain(@data[:left_exp])
+                  case chain_data
+                    when 'off', 'down', 'disable', '0', '', 0
+                      false
+                    else
+                      chain_data
+                  end
+                else
+                  op = '==' if op == '='
+                  expect_val = @data[:expect_val]
+                  data.get_by_chain(@data[:left_exp]).send(op, expect_val)
+                end
+          @data[:revert] ? !ret : ret
+        end
+      end
+
+      def <=>(other)
+        return 0 if @data == other.data
+        return nil if @data[:revert] != other.data[:revert] or @data[:left_exp] != other.data[:left_exp]
+
+        if @data[:op] == other.data[:op]
+          case @data[:op]
+            when '=', '=='
+              (@data[:expect_val] == other.data[:expect_val]) ? 0 : nil
+            when '>', '>='
+              @data[:expect_val] <=> other.data[:expect_val]
+            when '<', '<='
+              other.data[:expect_val] <=> @data[:expect_val]
+            when '?', nil
+              0
+            else
+              raise("内部错误:出现了不支持的表达式操作符号:#{@data[:op]}")
+          end
+        else
+          case [@data[:op], other.data[:op]]
+            when %w(< <=)
+              ret = other.data[:expect_val] <=> @data[:expect_val]
+              ret == 0 ? 1 : ret
+            when %w(< =)
+              @data[:expect_val] > other.data[:expect_val] ? -1 : nil
+            when %w(= >)
+              @data[:expect_val] > other.data[:expect_val] ? 1 : nil
+            when %w(= >=)
+              @data[:expect_val] >= other.data[:expect_val] ? 1 : nil
+            when %w(= <)
+              @data[:expect_val] < other.data[:expect_val] ? 1 : nil
+            when %w(= <=)
+              @data[:expect_val] <= other.data[:expect_val] ? 1 : nil
+            when %w(> >=)
+              ret = @data[:expect_val] <=> other.data[:expect_val]
+              ret == 0 ? 1 : ret
+            when %w(> =)
+              @data[:expect_val] < other.data[:expect_val] ? -1 : nil
+            when %w(>= =)
+              @data[:expect_val] <= other.data[:expect_val] ? -1 : nil
+            when %w(>= >)
+              ret = @data[:expect_val] <=> other.data[:expect_val]
+              ret == 0 ? -1 : ret
+            when %w(<= =)
+              @data[:expect_val] <= other.data[:expect_val] ? 1 : nil
+            when %w(<= <)
+              ret = other.data[:expect_val] <=> @data[:expect_val]
+              ret == 0 ? -1 : ret
+            else
+              nil
+          end
+        end
+      end
+
+      def to_s
+        ret = [:left_exp, :op, :expect_val].map { |k| @data[k] }.join
+        ret = '!' + ret if @data[:revert]
+        ret
+      end
+    end
+  end
+end

data/lib/tes/request/profile.rb

@@ -0,0 +1,282 @@
+require_relative 'ask'
+
+module Tes
+  module Request
+    class Profile
+      include Comparable
+
+      REG_POINT_ASK = /^\*(\d+):/
+      REG_REFER_ASK = /^&(\d+)\./
+      REG_POINT_ASK_GREEDY = /^\[\*(\d+)\]:/
+      REG_REFER_ASK_GREEDY = /^\[&(\d+)\]\./
+
+      # 深度解析环境要求
+      # @param [Array<String>] profile_lines 测试环境要求语句列表
+      def initialize(profile_lines=[])
+        @data = []
+
+        # 不因申明顺序不一致性等其他差异而误判环境要求的一致性
+        point_asks = {}
+        profile_lines.each do |line|
+          case line
+            when REG_POINT_ASK
+              mt = line.match(REG_POINT_ASK)
+              ask = Ask.new line.sub(REG_POINT_ASK, '')
+              point_asks[mt[1]] = ask
+            when REG_POINT_ASK_GREEDY
+              mt = line.match(REG_POINT_ASK_GREEDY)
+              ask = Ask.new line.sub(REG_POINT_ASK_GREEDY, '')
+              ask.greedy= true
+              point_asks[mt[1]] = ask
+            when REG_REFER_ASK
+              mt= line.match(REG_REFER_ASK)
+              src_ask = point_asks[mt[1]]
+              ref_exp = Expression.new line.sub(REG_REFER_ASK, '')
+              src_ask.reference << ref_exp
+            when REG_REFER_ASK_GREEDY
+              mt= line.match(REG_REFER_ASK_GREEDY)
+              src_ask = point_asks[mt[1]]
+              ref_exp = Expression.new line.sub(REG_REFER_ASK_GREEDY, '')
+              src_ask.reference << ref_exp
+            else
+              @data << Ask.new(line)
+          end
+        end
+
+        @data += point_asks.values
+      end
+
+      attr_reader :data
+
+      def <=>(other)
+        all_self_hash = self.data.group_by { |e| e.to_s }
+        all_self_hash_keys = Set.new all_self_hash.keys
+        all_other_hash = other.data.group_by { |e| e.to_s }
+        all_other_hash_keys = Set.new all_other_hash.keys
+
+        # 如果相等或者可比较则直接返回(只在相等的时候有效)
+        return 0 if all_self_hash == all_other_hash
+
+        hash1 = Hash[all_self_hash_keys.to_a.map { |e| [e, true] }]
+        all_other_hash_keys.to_a.each do |k|
+          hash1.include?(k)
+        end
+
+        if all_self_hash_keys == all_other_hash_keys
+          compare_when_keys_same(all_self_hash, all_other_hash)
+        elsif all_self_hash_keys < all_other_hash_keys
+          compare_when_keys_subset(all_self_hash, all_other_hash)
+        elsif all_self_hash_keys > all_other_hash_keys
+          ret = compare_when_keys_subset(all_other_hash, all_self_hash)
+          ret ? 0 - ret : ret
+        else
+          nil
+        end
+      end
+
+
+      def +(other)
+        ret = self.<=>(other)
+        case ret
+          when 0, 1
+            self
+          when -1
+            other
+          else
+            merge(other)
+        end
+      end
+
+      def merge_able?(other)
+        self.+(other)
+        true
+      rescue RuntimeError
+        false
+      end
+
+      # 向资源池环境中申请资源,但并不进行锁定,只是有礼貌的进行问询式申请
+      #   真需要使用资源,需要在其返回列表后向服务器申请锁定这些资源列表
+      # @param [Hash<String,Hash>] pool 所有空闲可用的资源池
+      def request(pool)
+        get_candidates_lab = ->(ask, answer_cache) do
+          pool.keys.select { |k| !answer_cache.include?(k) && ask.match?(pool[k]) }
+        end
+
+        answers_flat = []
+        answers = @data.map do |ask|
+          candidates = get_candidates_lab.call(ask, answers_flat)
+          unless candidates.size > 0
+            nil
+          else
+            if ask.greedy
+              answers_flat += candidates
+              unless ask.reference.size > 0
+                candidates
+              else
+                candidates.map do |candidate|
+                  refs = ask.reference.inject([]) do |t, r|
+                    ret = pool[candidate].get_by_chain(r.data[:left_exp])
+                    ret.is_a?(Array) ? (t + ret) : (t << ret)
+                  end
+                  answers_flat += refs
+                  [candidate, refs]
+                end
+              end
+            else
+              candidate = candidates.first
+              answers_flat << candidate
+              unless ask.reference.size > 0
+                candidate
+              else
+                refs = ask.reference.inject([]) do |t, r|
+                  ret = pool[candidate].get_by_chain(r.data[:left_exp])
+                  ret.is_a?(Array) ? (t + ret) : (t << ret)
+                end
+                answers_flat += refs
+                [candidate, refs]
+              end
+            end
+          end
+        end
+
+        answers
+      end
+
+      def to_s(split="\n")
+        ret = []
+        point = 0
+        @data.each do |ask|
+          if ask.reference and ask.reference.size > 0
+            point_ask = ask
+            refer_asks = ask.reference
+            point += 1
+            ret << ("*#{point}:" + point_ask.to_s)
+            refer_asks.each do |r_ask|
+              ret << ("&#{point}." + r_ask.to_s)
+            end
+          else
+            ret << ask.to_s
+          end
+        end
+        ret.join(split)
+      end
+
+      private
+      def compare_when_keys_same(hash_self, hash_other)
+        size_compare_results = hash_self.keys.map { |k| hash_self[k].size <=> hash_other[k].size }
+        if size_compare_results.all? { |v| v && v <= 0 }
+          size_compare_results.any? { |v| v == -1 } ? -1 : 0
+        elsif size_compare_results.all? { |v| v && v >= 0 }
+          size_compare_results.any? { |v| v == 1 } ? 1 : 0
+        else
+          nil
+        end
+      end
+
+      def compare_when_keys_subset(hash_self, hash_other)
+        subset_keys = hash_self.keys
+        hash_other_subset = subset_keys.inject({}) { |t, k| t.merge(k => hash_other[k]) }
+        ret = compare_when_keys_same(hash_self, hash_other_subset)
+        ret && (ret <= 0 ? -1 : nil)
+      end
+
+      # @return [Hash<Object,Array<Object>>]
+      def merge_when_keys_diff!(hash_self, hash_other)
+        merge_able_lab = ->(to, from) do
+          from.keys.all? do |f_ask|
+            if to.any? { |k, _| f_ask <=> k }
+              true
+            else
+              if f_ask.data['type']
+                to.keys.none? { |e| e.data['type'] && e.data['type'] and e.data['type'] == f_ask.data['type'] }
+              else
+                true
+              end
+            end
+          end
+        end
+        merge_lab = ->(to, from) do
+          # 现将内容全部拼起来,然后合并资源
+          ret_hash = {}
+          to.each { |ask, ask_dup_list| ret_hash[ask] = ask_dup_list }
+          from.each do |ask, ask_dup_list|
+            # 是否有相同要求的资源要求
+            if ret_hash[ask]
+              unless ret_hash[ask].size >= ask_dup_list
+                ret_hash[ask] += ask_dup_list[ret_hash[ask].size..-1]
+              end
+            else
+              # 没有
+
+              # 是否总结果中有可合并的资源请求
+              merge_able_ask = ret_hash.keys.find { |a| a <=> ask }
+              if merge_able_ask
+                if merge_able_ask >= ask
+                  if ret_hash[merge_able_ask].size < ask_dup_list.size
+                    ret_hash[merge_able_ask] += ask_dup_list[ret_hash[merge_able_ask].size..-1]
+                  end
+                else
+                  if ret_hash[merge_able_ask].size <= ask_dup_list.size
+                    ret_hash.delete(merge_able_ask)
+                    ret_hash[ask] = ask_dup_list
+                  else
+                    ret_hash[ask] = ask_dup_list
+                    ret_hash[merge_able_ask].pop(ask_dup_list.size)
+                  end
+                end
+              else
+                ret_hash[ask] = ask_dup_list
+              end
+            end
+          end
+
+          ret_hash
+        end
+
+        if merge_able_lab.call(hash_self, hash_other)
+          merge_lab.call(hash_self, hash_other)
+        elsif merge_able_lab.call(hash_other, hash_self)
+          merge_lab.call(hash_other, hash_self)
+        else
+          raise('冲突较大,不能合并')
+        end
+      end
+
+      def merge(other)
+        all_self_hash = self.data.group_by { |e| e.to_s }
+        all_self_hash = Hash[all_self_hash.map { |k, v| [Ask.new(k), v] }]
+        all_other_hash = other.data.group_by { |e| e.to_s }
+        all_other_hash = Hash[all_other_hash.map { |k, v| [Ask.new(k), v] }]
+        all_self_hash_keys = Set.new all_self_hash.keys
+        all_other_hash_keys = Set.new all_other_hash.keys
+
+        merge_when_same_keys_lab = ->(keys) do
+          keys.inject({}) do |t, k|
+            if all_self_hash[k].size >= all_other_hash[k].size
+              t.merge k => all_self_hash[k]
+            else
+              t.merge k => all_other_hash[k]
+            end
+          end
+        end
+
+        result = if all_self_hash_keys == all_other_hash_keys
+                   merge_when_same_keys_lab.call(all_self_hash_keys)
+                 elsif all_self_hash_keys < all_other_hash_keys
+                   ret = merge_when_same_keys_lab.call(all_self_hash_keys)
+                   all_other_hash.merge(ret)
+                 elsif all_self_hash_keys > all_other_hash_keys
+                   ret = merge_when_same_keys_lab.call(all_other_hash_keys)
+                   all_self_hash.merge(ret)
+                 else
+                   merge_when_keys_diff!(all_self_hash, all_other_hash)
+                 end
+        new_instance = self.class.new([])
+
+
+        result.values.flatten.each { |v| new_instance.data.push v }
+        new_instance
+      end
+    end
+  end
+end

data/lib/tes/request/rake_task.rb

@@ -0,0 +1,90 @@
+require 'rake'
+require 'rake/tasklib'
+require 'yaml'
+require 'java-properties'
+require_relative 'rspec/distribute'
+
+class Tes::Request::RakeTask < ::Rake::TaskLib
+  SUPPORT_FILE_TYPES = [:yaml, :yml, :json, :properties]
+
+  def initialize(name, type)
+    desc "Generate RSpec distribute jobs #{type} file for CI"
+    task name, [:project_dir, :type, :count, :version, :lang] do |_, task_args|
+      rspec_distribute = ::Tes::Request::RSpec::Distribute.new(task_args[:project_dir])
+      jobs = rspec_distribute.distribute_jobs(task_args[:type],
+                                              task_args[:count].to_i,
+                                              task_args[:version],
+                                              task_args[:lang])
+      target_dir = File.join(task_args[:project_dir], '.ci_jobs')
+      save_job_files(jobs, target_dir, type)
+    end
+  end
+
+  def spec_tag_param_str(tags)
+    case tags
+      when Array
+        tags.map { |t| "--tag #{t}" }.join(' ')
+      when String
+        "--tag #{tags}"
+      when nil
+        nil
+      else
+        raise("不支持的类型:#{tags.class}")
+    end
+  end
+
+  def save_job_files(jobs, target_dir, file_type)
+    unless SUPPORT_FILE_TYPES.include?(file_type)
+      raise(ArgumentError, "Not supported file type:#{file_type}!")
+    end
+
+    job_configs_for_ci = jobs.map { |j| gen_job_ci_params(j) }
+    FileUtils.rm_rf(target_dir)
+    FileUtils.mkdir(target_dir)
+    case file_type
+      when :json
+        save_file = File.join(target_dir, 'ci_tasks.json')
+        File.open(save_file, 'w') { |f| f.write job_configs_for_ci.to_json }
+        puts "Generated #{jobs.size} jobs, Stored in:#{save_file} ."
+      when :yml, :yaml
+        save_file = File.join(target_dir, 'ci_tasks.yml')
+        File.open(save_file, 'w') { |f| f.write job_configs_for_ci.to_yaml }
+        puts "Generated #{jobs.size} jobs, Stored in:#{save_file} ."
+      when :properties
+        job_configs_for_ci.each_with_index do |params, i|
+          file = File.join(target_dir, "#{i}.properties")
+          save_job_properties(params, file)
+        end
+        puts "Generated #{jobs.size} jobs, Stored in:#{target_dir}/*.properties ."
+    end
+  end
+
+  def save_job_properties(job_cfg, save_file)
+    # context = ["# gen at #{Time.now}"]
+    JavaProperties.write(job_cfg, save_file)
+    #
+    # context = ["# gen at #{Time.now}"]
+    # tag_opt_cli_args = spec_tag_param_str(job_cfg[:tag])
+    # rspec_param = if tag_opt_cli_args
+    #                 "RSPEC_PARAM = #{tag_opt_cli_args} \\\n\t#{piece[:files].join(" \\\n\t")}"
+    #               else
+    #                 "RSPEC_PARAM = #{piece[:files].join(" \\\n\t")}"
+    #               end
+    # context << "REQUEST_ASKS = #{piece[:profile].to_s(";\\\n\t")}"
+    # File.open(file, 'w') { |f| f.write context.join("\n") }
+  end
+
+  def get_job_rspec_run_args_str(job, split=' ')
+    tags_str = spec_tag_param_str(job[:tag])
+    paths_str = job[:specs].join(split)
+    tags_str ? (tags_str + split + paths_str) : paths_str
+  end
+
+  def get_job_env_profile_str(job, split=';')
+    job[:profile].to_s(split)
+  end
+
+  def gen_job_ci_params(job)
+    {'RSPEC_PARAM' => get_job_rspec_run_args_str(job), 'REQUEST_ASKS' => get_job_env_profile_str(job)}
+  end
+end