herokubench 0.0.8 → 0.0.9

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Y2M1MzM3ZTcwZTE3NDViYmJhNmYwYmI0ZmViNGU4OWYyY2Y3NjA0Yg==
-  data.tar.gz: !binary |-
-    NDVjOGUzNDdlNGFkZjIxOTc1ZDMwMzQ0NzEwN2Q4MjIyZjNiN2JmMA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ZmQ0NTk5Y2U4YmY4YjRjZGEzYTYwMTFhMjFmOTZhZmMzNDBlNWZkYTM2MWU2
-    ZmYyYTRiZDk0NTljNGM4ZTMzOTU3YTJmNjdmYTc2MWVkNTJlNGU3YzBjZmM4
-    YzQ2NGQ5ZTUwYjYwMDFhMDhhMTk1ZWU3NTMxY2E2ZGFkOGExODY=
-  data.tar.gz: !binary |-
-    NzVjOTE1NmYzZWE5NDJhZGFjNTJlMDI1ZWQ1MTlkODUzNGZlMzc5MzZhNWU4
-    NGYwNTYwNGQ4NjIxM2E4NjJjYjJhNGI3ZmUwZmM0MjNmYzE0MDNlYmRjYTkz
-    NjI5YzkxOTBmNDFkNGY5Y2RkMzFjNWEyM2VhMmI5NmFiYmM4MTY=
+SHA1:
+  metadata.gz: cb2da4a4361fae8687d6f1000bc956fa668f09ab
+  data.tar.gz: 1468528eb35ebf73b7cb01cf16b0a19f9c7017a1
+SHA512:
+  metadata.gz: fbad4b333c5c4e3704634f4cef8481b16928d92efd1f10ffd62b35aec857b581fa654cd4e78c1851555378e170e6f542966bb80593e9bd04b64fe35190e6822e
+  data.tar.gz: 40dc3ab2b9b76868efacbd43ac1f7663fd4467c446ef91fb2cef612e02472d593eb56bdaa0a4ce44add5d86f12c5e95e9eaaff7565504169cfeb49a0ab2ec903

data/bin/hbench

@@ -6,4 +6,7 @@ require "tmpdir"
 require "uri"
 require "herokubench/cli"
 
+STDOUT.sync = true
+
+
 HerokuBench::CLI.start

data/bin/herokubench

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "tmpdir"
+require "uri"
+require "herokubench/cli"
+
+STDOUT.sync = true
+
+HerokuBench::CLI.start

data/lib/herokubench/bencher.rb

@@ -6,6 +6,7 @@ require "heroku/command/help"
 require "heroku/command/apps"
 require "heroku/cli"
 require "heroku/plugin"
+STDOUT.sync = true
 
 Heroku.user_agent = "heroku-gem/#{Heroku::VERSION} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 Heroku::Command.load

data/lib/herokubench/cli.rb

@@ -15,7 +15,8 @@ require "pathname"
 require "stringio"
 require 'tempfile'
 require 'ruby-progressbar'
-
+$:.unshift File.expand_path("../../lib", __FILE__)
+require 'herokubench/result'
 
 # This class is based upon Vulcan, and copies heavily.
 
@@ -23,18 +24,6 @@ class HerokuBench::CLI < Thor
   class_option "verbose",  :type => :boolean
   check_unknown_options!  :except => [:ab, :multi]
   default_task :ab
-  @@result_type = {
-    :connection_times=>/(.+):\s+\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)/,
-    :generic_result=> /^([\w\s]+):\s*([\d|\.]+)/,
-    :response_time_cdf=>/(\d+%)\s+(\d+)/
-  }
-  @@summable_fields = ["Complete requests","Failed requests", "Write errors", "Requests per second",
-                      "Total Transferred", "HTML transferred", "Concurrency Level"
-                      ]
-  @@medianable_fields = ["Connect", "Processing", "Waiting", "Total", "Time per request",
-                        ]
-  @@maxable_fields    = ["50%", "66%", "75%", "80%", "90%", "95%", "98%", "99%","100%"]
-
   class_options["verbose"] = false if class_options["verbose"].nil?
   Heroku.user_agent = "heroku-gem/#{Heroku::VERSION} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
   Heroku::Command.load
@@ -68,6 +57,7 @@ class HerokuBench::CLI < Thor
   LONGDESC
 
   def ab(*args)
+    puts config[:app]
     error "no app yet, please create first" unless config[:app]
     puts "Running one-off dyno, please be patient"
     Heroku::Command.run("run", ["ab #{args.join(' ')}", "--app", "#{config[:app]}"])
@@ -88,43 +78,63 @@ class HerokuBench::CLI < Thor
   def multi(dynos, *args)
     error "no app yet, create first" unless config[:app]
     error "Number of dynos must be an integer greater than 1" unless dynos.to_i >= 1
+    begin
+      num_requests = args[args.index("-n") + 1].to_i #hack to extract number of requests from the ab arguments.
 
-    bencher_path = File.expand_path("../bencher.rb",__FILE__)
+      bencher_path = File.expand_path("../bencher.rb",__FILE__)
 
-    dynos = dynos.to_i
-    outputs = []
-    pid_map = {}
-    results = []
-    n = 0
+      numdynos = dynos.to_i
+      results = []
+      running_procs = {}
+      progesses = {}
+      ab_command = "ab #{args.join(' ')}"
 
-    ab_command = "ab #{args.join(' ')}"
+      p_bar = ProgressBar.create(:title=>'Benching',:total=>numdynos*num_requests, :smoothing => 0.6)
 
-    p_bar = ProgressBar.create(:title=>'Benching',:total=>dynos, :smoothing => 0.6)
-
-    until n == dynos do
-      outputs.push Tempfile.new("hbench_out_#{n}")
-      pid = spawn( "ruby #{bencher_path} \"#{ab_command} \" --app #{config[:app]}", :out=>outputs[n].path)
-      pid_map[pid] = n
-      n += 1
-    end
+      numdynos.times do  |n|
+        t_file = Tempfile.new("hbench_out_#{n}") 
+        pid = spawn( "ruby #{bencher_path} \"#{ab_command} \" --app #{config[:app]}", :out=>t_file.path, :err=>null_dev)
+        running_procs[pid] = t_file
+        progesses[pid] = 0
+        puts t_file.path
+      end
 
 
-    until n == 0 do
-      output =  outputs[pid_map[Process.wait]]
-      if n ==1
-        last_output = output.read if n ==1
-        output.rewind
+      until running_procs.empty?
+        begin
+          complete_results = Timeout.timeout(1) do
+            pid = Process.wait
+            results.push running_procs.delete(pid)
+            p_bar.progress += num_requests - progesses[pid]
+            progesses[pid] = num_requests
+          end
+        rescue Timeout::Error
+          running_procs.each do |pid, tfile|
+            progress = get_progress(tfile)
+            p_bar.progress += progress - progesses[pid]
+            progesses[pid] = progress
+          end
+        end
       end
-      p_bar.increment
-      results.push get_result_hash output
-      output.unlink
-      n -= 1
-    end
-
-    if results.last.length == 3
-      summarize results
-    else
-      error last_output
+      
+      summary_result  = ApacheBenchSummaryResult.new
+
+      puts results
+      results.each  do |tfile|
+        summary_result.add_result(ApacheBenchResult.new(tfile))
+      end 
+      summary_result.print()
+
+
+    rescue Interrupt
+      say "Exiting...Please be patient"
+      kill_running_procs(running_procs)
+      kill_running_dynos()
+      say "Done"
+    rescue => exception
+      say("HerokuBench ran into an unexpected exception. Please contact @wcdolphin",:red)
+      say(exception,:red)
+      puts exception.backtrace
     end
   end
 
@@ -138,50 +148,79 @@ class HerokuBench::CLI < Thor
 
   # pretty much the opposite of parse. Returns a string of the best way
   # to represent a float, int or string value
-  def unparse(v)
+  def serialize(v)
     ((float = v.round(1)) && (float % 1.0 == 0) ? float.to_i.to_s : float.to_s) rescue v.to_s
   end
 
-  def summarize(results)
-    summary = {}
-
-    results.each do |result|
-      result.each do |type, hash|
-        summary[type] = {} if summary[type].nil?
-        hash.each do |k,v|
-          summary[type][k] = [0.0] * v.length if summary[type][k].nil?
-          v.each_index do |i|
-            if not @@summable_fields.index(k).nil?
-              summary[type][k][i] += v[i]
-            elsif not @@medianable_fields.index(k).nil?
-              summary[type][k][i] += v[i] / results.length.to_f
-            elsif not @@maxable_fields.index(k).nil?
-              summary[type][k][i] = [v[i], summary[type][k][i]].max
-            else
-              summary[type][k][i] = v[i]
-            end
-          end
-        end
-      end
-    end
+  def get_progress(tfile)
+    tfile.rewind
 
-    say "\tCumulative results, summed across dynos"
-    say ""
-    summary[:generic_result].each{|k,v| say format(k+":",v, 25)}
-
-    say ""
-    say "\t Connection Times (ms), median across dynos"
-    say format("",["min", "mean", "[+/-sd]" ,"median","max"],15)
-    summary[:connection_times].each{|k,v| say format(k+":",v, 15)}
+    progress = tfile.each_line.collect do |line|
+      group = line.scan(/Completed (\d+) requests/)
+      group = group.empty? ? 0 : group[0][0]
+    end
+    progress = progress.last.to_i
+  end
+  # def summarize(results)
+  #   summary = {}
+
+  #   results.each do |result|
+  #     result.each do |type, hash|
+  #       summary[type] = {} if summary[type].nil?
+  #       hash.each do |k,v|
+  #         summary[type][k] = [0.0] * v.length if summary[type][k].nil?
+  #         v.each_index do |i|
+  #           if not @@summable_fields.index(k).nil?
+  #             summary[type][k][i] += v[i]
+  #           elsif not @@medianable_fields.index(k).nil?
+  #             summary[type][k][i] += v[i] / results.length.to_f
+  #           elsif not @@maxable_fields.index(k).nil?
+  #             summary[type][k][i] = [v[i], summary[type][k][i]].max
+  #           else
+  #             summary[type][k][i] = v[i]
+  #           end
+  #         end
+  #       end
+  #     end
+  #   end
+
+  #   say "\tCumulative results, summed across dynos"
+  #   say ""
+  #   summary[:generic_result].each{|k,v| say format(k+":",v, 25)}
+
+  #   say ""
+  #   say "\t Connection Times (ms), median across dynos"
+  #   say format("",["min", "mean", "[+/-sd]" ,"median","max"],15)
+  #   summary[:connection_times].each{|k,v| say format(k+":",v, 15)}
+
+  #   say ""
+  #   say "\t Percentage of the requests served within a certain time (ms)"
+  #   say "\t across dynos"
+  #   summary[:response_time_cdf].each{|k,v| say format(k+"",v, 15)}
+  # end
+
+  def kill_running_procs(running_procs)
+      print "Killing running processes"
+      running_procs.keys.each do |pid|
+        Process.kill("INT", pid)
+        print "."
+      end
+  end
 
-    say ""
-    say "\t Percentage of the requests served within a certain time (ms)"
-    say "\t across dynos"
-    summary[:response_time_cdf].each{|k,v| say format(k+"",v, 15)}
+  def kill_running_dynos()
+    print "\nKilling running dynos"
+    result = capture { Heroku::Command.run("ps", ["--app", "#{config[:app]}"]) }
+    result.split("\n").each do |line|
+      dyno_name = line.scan(/(run.[\d]+)/)
+      unless dyno_name.nil? or dyno_name.empty?
+        capture {Heroku::Command.run("ps:stop", ["#{dyno_name[0][0]}","--app", "#{config[:app]}"])}
+        print '.'
+      end
+    end
   end
 
   def format(k,v, pad)
-    "#{fill(k,pad)}#{v.map{|val| fill(unparse val)}.join('')}\r\n"
+    "#{fill(k,pad)}#{v.map{|val| fill(serialize val)}.join('')}\r\n"
   end
 
   def fill(str, length=12)
@@ -194,86 +233,84 @@ class HerokuBench::CLI < Thor
       @@result_type.each do |k,v|
         group = line.scan(v)
         if not group.nil? and group.length.equal? 1
-                capture = group[0].map {|v| parse v} #convert to float/int/etc
-                result_hash[k] = {} unless result_hash.has_key?(k)
-                res_key = capture[0]
-                res_values = capture.slice(1, capture.length)
-                result_hash[k][res_key] = res_values
-              end
-            end
-          end
-          result_hash
-        end
-
-        def update
-          error "no app yet, create first" unless config[:app]
-
-          Dir.mktmpdir do |dir|
-            Dir.chdir(dir) do
-              system "git init -q"
-              system "git remote add origin git@github.com:wcdolphin/heroku-benchserver.git"
-              system "git remote add heroku git@#{heroku_git_domain}:#{config[:app]}.git"
-              pullres = capture { system "git pull --quiet origin master"}
-              pushres = capture { system "git push heroku master --quiet"}
-            end
-          end
+          capture = group[0].map {|v| parse v} #convert to float/int/etc
+          result_hash[k] = {} unless result_hash.has_key?(k)
+          res_key = capture[0]
+          res_values = capture.slice(1, capture.length)
+          result_hash[k][res_key] = res_values
         end
+      end
+    end
+    result_hash
+  end
 
-        def capture
-          results = $stdout = StringIO.new
-          yield
-          $stdout = STDOUT
-          results.close_write
-          results.rewind
-          return results.read
-        end
+  def update
+    error "no app yet, create first" unless config[:app]
 
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        system "git init -q"
+        system "git remote add origin git@github.com:wcdolphin/heroku-benchserver.git"
+        system "git remote add heroku git@#{heroku_git_domain}:#{config[:app]}.git"
+        pullres = capture { system "git pull --quiet origin master"}
+        pushres = capture { system "git push heroku master --quiet"}
+      end
+    end
+  end
 
+  def capture
+    results = $stdout = StringIO.new
+    yield
+    $stdout = STDOUT
+    results.close_write
+    results.rewind
+    return results.read
+  end
 
- #Yeah, we are windows compatible. Because you should be too.
- def null_dev
-  return test(?e, '/dev/null') ? '/dev/null' : 'NUL:'
-end
+  #Yeah, we are windows compatible. Because you should be too.
+  def null_dev
+    return test(?e, '/dev/null') ? '/dev/null' : 'NUL:'
+  end
 
-def action(message)
-  print "#{message}... "
-  yield
-  puts "done"
-end
+  def action(message)
+    print "#{message}... "
+    yield
+    puts "done"
+  end
 
-def heroku(command)
-  %x{ env BUNDLE_GEMFILE= heroku #{command} 2>&1 }
-end
+  def heroku(command)
+    %x{ env BUNDLE_GEMFILE= heroku #{command} 2>&1 }
+  end
 
-def config_file
-  File.expand_path("~/.herokubench")
-end
+  def config_file
+    File.expand_path("~/.herokubench")
+  end
 
-def config
-  read_config
-end
+  def config
+    read_config
+  end
 
-def read_config
-  return {} unless File.exists?(config_file)
-  config = YAML.load_file(config_file)
-  config.is_a?(Hash) ? config : {}
-end
+  def read_config
+    return {} unless File.exists?(config_file)
+    config = YAML.load_file(config_file)
+    config.is_a?(Hash) ? config : {}
+  end
 
-def write_config(config)
-  full_config = read_config.merge(config)
-  File.open(config_file, "w") do |file|
-    file.puts YAML.dump(full_config)
+  def write_config(config)
+    full_config = read_config.merge(config)
+    File.open(config_file, "w") do |file|
+      file.puts YAML.dump(full_config)
+    end
   end
-end
 
-def error(message)
-  puts "!! #{message}"
-  exit 1
-end
+  def error(message)
+    puts "!! #{message}"
+    exit 1
+  end
 
-def server_path
-  File.expand_path("../../../server", __FILE__)
-end
+  def server_path
+    File.expand_path("../../../server", __FILE__)
+  end
 
   #
   # heroku_git_domain checks to see if the heroku-accounts plugin is present,

data/lib/herokubench/result.rb

@@ -0,0 +1,143 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "thor"
+require "digest/sha1"
+require "heroku/auth"
+require "heroku/command"
+require "heroku/command/base"
+require "heroku/command/help"
+require "heroku/command/apps"
+require "heroku/cli"
+require "heroku/plugin"
+require "thor"
+require "tmpdir"
+require "uri"
+require "herokubench"
+require "yaml"
+require "pathname"
+require "stringio"
+require 'tempfile'
+require 'ruby-progressbar'
+
+
+class BaseResult
+	@@summable_fields = []
+	@@maxable_fields = []
+end
+
+class ApacheBenchResult < BaseResult
+  attr_accessor :result_hash
+  @@result_regexes = {
+    :connection_times=>/(.+):\s+\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)\s+([\d|\.]+)/,
+    :generic_result=> /^([\w\s]+):\s*([\d|\.]+)/,
+    :response_time_cdf=>/(\d+%)\s+(\d+)/
+  }
+  @@summable_fields = ["Complete requests","Failed requests", "Write errors", "Requests per second", "Total transferred", "HTML transferred", "Concurrency Level"]
+  @@averageable_fields = ["Connect", "Processing", "Waiting", "Total", "Time per request", "Time taken for tests"]
+  @@maxable_fields    = ["50%", "66%", "75%", "80%", "90%", "95%", "98%", "99%","100%"]
+
+	def initialize(temp_file)
+		@result_hash = {}
+
+		temp_file.each_line do |line|
+		  @@result_regexes.each do |type,v|
+		    group = line.scan(v)
+		    if not group.nil? and group.length.equal? 1
+		      capture = group[0].map {|v| parse v} #convert to float/int/etc
+		      res_key = capture[0]
+		      res_values = capture.slice(1, capture.length)
+
+		      @result_hash[type] = {} unless @result_hash.has_key? type
+		      @result_hash[type][res_key] = res_values.length == 1 ? res_values[0] : res_values  
+		    end
+		  end
+		 end
+		puts @result_hash
+	end
+
+end
+
+class ApacheBenchSummaryResult < ApacheBenchResult
+
+	def initialize()
+		@results = []
+	end
+
+	def add_result(ab_result)
+		@results.push ab_result
+	end
+
+	def get_summary_result()
+		summary_result_hash = {}
+
+		@results.each do |result|
+			result.result_hash.each do |result_type, res_type_hashes| 
+				summary_result_hash[result_type] = {} unless summary_result_hash.has_key? result_type
+				res_type_hashes.each do |result_key, value|
+					summary_result_hash[result_type][result_key] = [] unless summary_result_hash[result_type].has_key? result_key
+					summary_result_hash[result_type][result_key].push value
+				end
+			end	
+		end
+
+		summary_result_hash.each do |result_type, result_hash|
+			result_hash.each do |result_name, result_values| 
+				if @@summable_fields.include? result_name
+					summary_result_hash[result_type][result_name] = result_values.inject(:+)			
+				elsif @@averageable_fields.include? result_name
+					summary_result_hash[result_type][result_name] = deep_average(result_values)
+				elsif  @@maxable_fields.include? result_name
+					summary_result_hash[result_type][result_name] = result_values.max
+				else
+					summary_result_hash[result_type][result_name] = result_values.first
+				end
+			end
+		end
+
+		summary_result_hash		
+	end
+	def print
+		# puts "-----"
+		summary = self.get_summary_result()
+		# puts summary
+		puts "-----"
+		puts "\t Cumulative results, summed across dynos"
+		puts ""
+		summary[:generic_result].each{|k,v| printf "%-20s %s\n", k + ":",v}
+
+		puts ""
+		puts "\t Connection Times (ms), median across dynos"
+		printf "%-20s %-6s %-6s %-6s %s\n", "","min", "mean", "[+/-sd]" ,"median","max"
+		summary[:connection_times].each do |k,v|
+			printf "%-20s %-6s %-6s %-6s %s\n",k +":", v[0], v[1], v[2], v[3], v[4], v[5]
+		end
+		puts ""
+		puts "\t Percentage of the requests served within a certain time (ms)"
+		puts "\t across dynos"
+		summary[:response_time_cdf].each{|k,v| printf "  %-20s %s\n", k,v}
+
+	end
+
+end
+
+
+
+private
+
+def parse(v)
+  ((float = Float(v)) && (float % 1.0 == 0) ? float.to_i : float) rescue v
+end
+
+def deep_average(arr)
+	result = []
+	if not arr.empty? and arr[0].is_a? Array #we need to do a 'deep' average.
+		arr[0].each_index do |i|
+			result[i] = arr.collect {|a| a[i]/arr.length.to_f}.inject(:+)
+		end
+		result
+	else	
+		arr.collect {|a| a/arr.length}.inject(:+)
+	end
+end
+
+
+

data/lib/herokubench/version.rb

@@ -1,5 +1,5 @@
 module HerokuBench
 
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 
 end

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: herokubench
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Cory Dolphin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2013-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: heroku
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.26.0
     - - <
@@ -24,7 +24,7 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.26.0
     - - <
@@ -48,35 +48,43 @@ dependencies:
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.1.1
-description: ! "      Make it rain on the cloud.\n\n      herokubench, or hb for short,
-  is a simple gem which eanbles you to easily load test websites,\n      using a server
-  hosted by Heroku (on AWS). The gem manages deploying\n      an app with no running
-  dynos (free), and abuses the concept of one-off\n      jobs to run the Apache Benchmark,
-  ab.\n\n      Confused? Checkout `hb help`\n"
+        version: 1.2.0
+description: |2
+        Make it rain on the cloud.
+
+        herokubench, or hb for short, is a simple gem which eanbles you to easily load test websites,
+        using a server hosted by Heroku (on AWS). The gem manages deploying
+        an app with no running dynos (free), and abuses the concept of one-off
+        jobs to run the Apache Benchmark, ab.
+
+        Confused? Checkout `hb help`
 email: wcdolphin@gmail.com
 executables:
 - hbench
+- herokubench
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/hbench
+- bin/herokubench
 - lib/herokubench/bencher.rb
 - lib/herokubench/cli.rb
+- lib/herokubench/result.rb
 - lib/herokubench/version.rb
 - lib/herokubench.rb
 - README.md
 homepage: https://github.com/wcdolphin/heroku-bench
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: Please run 'hbench create' to create your bench-server.
 rdoc_options: []
@@ -84,12 +92,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []