lavin 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ed47d43b5e5f91e1af2c3e319fa03d3588aee9826215394038359e559773a173
+  data.tar.gz: 17261c42f46a7c4e1ecff28adbd92434c5ec66ac28d4c208d6195a55bf49f69d
+SHA512:
+  metadata.gz: 747a493c85dd8fe99c5da92d9fc8380248f80a7b0483bfe42ba3f48fc8a06c89ecc45dfa02f424304b75d28709dfd7c35bc9137a658b22cb449dab91a4bb13ff
+  data.tar.gz: 304de7aa069cb83a61f3530bec34df37349e4572cdc4eb23ec20b86daa4a75606f207248f7b4efe5f3338d8f4166ba94c71ee33e856bc22e6cb36720585627cf

data/bin/lavin

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH <<  File.expand_path("../lib", __dir__)
+require 'lavin'
+require 'optionparser'
+
+module Lavin
+  class Script
+    def self.run(*files, web_ui: true)
+      exit_with_usage(msg: "No file or directory given") if files.empty?
+      files.keep_if { |file| File.exists? file }
+      new(*files, web_ui:).run
+    end
+
+    def self.usage
+      puts "\nUsage: #{$PROGRAM_NAME} PATH_TO_DIRECTORY_OR_FILE [*PATH_TO_DIRECTORY_OR_FILE]"
+    end
+
+    def self.exit_with_usage(msg: nil, status: 1)
+      puts msg if msg
+      usage
+      exit(status)
+    end
+
+    attr_reader :files, :web_ui
+
+    def initialize(*files, web_ui: true)
+      @files = files
+      @web_ui = web_ui
+    end
+
+    def run
+      files.each do |file|
+        if Dir.exists? file
+          $LOAD_PATH << file unless $LOAD_PATH.include? file
+          Dir.children(file).each { |file| require file }
+        else
+          $LOAD_PATH << "." unless $LOAD_PATH.include? "."
+          require file
+        end
+      end
+
+      if web_ui
+        require 'lavin/web_server'
+        Lavin::WebServer.run!
+      else
+        runner = Lavin::Runner.new
+        runner.start
+        runner.wait
+        Statistics.show
+      end
+    end
+  end
+
+  if (ARGV & ["-h", "--help"]).size.positive?
+    Script.exit_with_usage(status: 0)
+  else
+    web_ui = ARGV.delete("--no-web").nil?
+    Script.run(*ARGV, web_ui:)
+  end
+end

data/lib/lavin/client.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'async/http/internet'
+
+module Lavin
+  class Client
+    class Error < Lavin::Error; end
+    class NoCurrentAsyncTaskError < Error
+      def initialize(msg = nil)
+        super(msg || "Trying to create a client outside of an Async task")
+      end
+    end
+
+    DEFAULT_HEADERS = {
+      'User-Agent'=> 'LavinLoadTest',
+      'Accept' => '*/*',
+    }.freeze
+
+    attr_reader :internet, :base_url
+    attr_accessor :request_count, :cookie
+
+    def initialize(base_url = nil)
+      raise NoCurrentAsyncTaskError unless Async::Task.current?
+
+      @internet = Async::HTTP::Internet.new
+      @base_url = base_url
+      @request_count = 0
+      @cookie = nil
+    end
+
+    def close
+      internet.close
+    end
+
+    def request(method, url:, headers:, body: nil)
+      url, headers, body = rewrite_request(url:, headers:, body:)
+
+      start_time = Time.now
+      response = internet.send(method, url, headers, body)
+      duration = Time.now - start_time
+
+      status, headers, body = process(response)
+
+      Statistics.register_request(method:, url:, status:, duration:)
+
+      {status:, headers:, body: body}
+    end
+
+    private
+
+    def rewrite_request(url:, headers:, body:)
+      headers = DEFAULT_HEADERS.merge(headers || {})
+      headers["Cookie"] = cookie if cookie
+
+      if body.is_a? Hash
+        body = JSON.dump(body)
+        headers["Content-Type"] = "application/json"
+      end
+
+      url = File.join(base_url, url) if base_url && !url.start_with?(/https?:/)
+
+      [url, headers, body]
+    end
+
+    def process(response)
+      status = response.status
+      headers = response.headers
+      body = response.read
+      save_cookie(headers)
+      self.request_count += 1
+
+      [status, headers, body]
+    end
+
+    def save_cookie(headers)
+      cookie = headers['Set-Cookie'] || headers['SET-COOKIE'] || headers['set-cookie']
+      self.cookie = cookie if cookie
+    end
+  end
+end

data/lib/lavin/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lavin
+  class Error < StandardError; end
+end

data/lib/lavin/http_client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'lavin/client'
+
+module Lavin
+  module HttpClient
+    attr_reader :client
+    attr_writer :index
+
+    def initialize(**kwargs)
+      super(**kwargs)
+      @client = Client.new(config[:base_url])
+    end
+
+    def cleanup
+      client&.close
+    end
+
+    def get(url, headers: {})
+      client.request(:get, url:, headers:)
+    end
+
+    def head(url, headers: {})
+      client.request(:head, url:, headers:)
+    end
+
+    def post(url, headers: {}, body: nil)
+      client.request(:post, url:, headers:, body:)
+    end
+
+    def put(url, headers: {}, body: nil)
+      client.request(:put, url:, headers:, body:)
+    end
+
+    def patch(url, headers: {}, body: nil)
+      client.request(:patch, url:, headers:, body:)
+    end
+
+    def delete(url, headers: {})
+      client.request(:delete, url:, headers:)
+    end
+  end
+end

data/lib/lavin/runner.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'lavin/user'
+require 'lavin/statistics'
+
+module Lavin
+  class Runner
+    class Entry
+      class DepletedError < Lavin::Error
+        def initialize(msg = nil)
+          super(msg || "Depleted")
+        end
+      end
+
+      attr_reader :persona, :name
+      attr_accessor :count
+
+      def initialize(persona)
+        @persona = persona
+        @name = persona.config[:name]
+        @count = persona.user_count
+      end
+
+      def present?
+        count.positive?
+      end
+
+      def get
+        raise DepletedError unless present?
+
+        self.count -= 1
+        persona
+      end
+    end
+
+    attr_reader :personas, :total_users, :remaining
+    attr_accessor :spawned_users, :index
+
+    class << self
+      attr_accessor :thread
+
+      def yield
+        Async::Task.current.yield if Async::Task.current?
+      end
+
+      def start
+        new.start
+      end
+
+      def start_async
+        self.thread = Thread.new do
+          new.start
+          stop
+          exit
+        end
+      rescue StandardError => error
+        puts "Failed to run in thread: #{error.message}"
+        thread.join
+        thread = nil
+        raise
+      end
+
+      def stop
+        Statistics.stop
+        thread&.kill
+        self.thread = nil
+      end
+
+      def running?
+        return false unless thread
+        return true if %w[run sleep].include? thread.status
+
+        stop
+        false
+      end
+    end
+
+    def initialize(personas: nil)
+      @personas = personas || User.personas
+      @remaining = @personas.map { |persona| Entry.new(persona) }
+      @total_users = @remaining.sum(&:count)
+      @spawned_users = 0
+      @index = -1
+    end
+
+    def start
+      Statistics.meassure { create_async_task }
+    rescue StandardError => error
+      puts "Failed to run tasks: #{error.message}"
+      raise
+    ensure
+      stop
+    end
+
+    def create_async_task
+      @task = Async(annotation: "Main") do |task|
+        spawn(count: total_users) do |persona|
+          next unless persona
+
+          user_index = spawned_users
+          annotation = "User: #{persona.name} ##{user_index}"
+          task.async(annotation:) do |user_task|
+            user = persona.new(user_index:, task: user_task)
+            user.run
+          ensure
+            user.cleanup
+          end
+        end
+      end
+    end
+
+    def wait
+      @task&.wait
+    end
+
+    def stop
+      @task&.stop
+      @task&.wait
+    end
+
+    def spawn(count: 1)
+      count.times do
+        persona = next_persona
+        break unless persona
+
+        self.spawned_users += 1
+        yield persona
+      end
+    end
+
+    def next_persona
+      self.index += 1
+
+      entry = remaining[index % remaining.size]
+      if entry.present?
+        entry.get
+      elsif remaining.any?(&:present?)
+        next_persona
+      end
+    end
+  end
+end

data/lib/lavin/statistics.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'lavin/stats'
+
+module Lavin
+  class Statistics
+    class << self
+      # FIXME: make thread safe
+
+      def meassure
+        reset
+        data[:start] = Time.now
+        yield.tap { data[:duration] = Time.now - data[:start] }
+      end
+
+      def reset
+        self.data = new_data
+      end
+
+      def stop
+        return if data.frozen?
+
+        data[:duration] = (Time.now - data[:start])
+        data.freeze
+      end
+
+      def total_requests
+        data[:total_requests]
+      end
+
+      def duration
+        return data[:duration] if data[:duration]
+
+        Time.now - data[:start] if data[:start]
+      end
+
+      def register_request(method:, url:, status:, duration:)
+        data[:total_requests] += 1
+        key = [method, url]
+        result = {status:, duration:}
+        result[:failure] = true if status > 499
+        data[:requests][key] << result
+      end
+
+      def register_step
+        # TODO
+      end
+
+      def stats
+        reset unless data
+        time = Time.now
+
+        requests = data[:requests].map do |(method, url), requests|
+          durations = []
+          statuses = []
+          requests.each do |request|
+            durations << request[:duration]
+            statuses << request[:status]
+          end
+          min_duration = durations.min
+          max_duration = durations.max
+          avg_duration = durations.empty? ? 0 : (durations.sum / durations.size)
+
+          {
+            method: method.to_s.upcase,
+            url: url,
+            requests: requests.size,
+            statuses: statuses.tally,
+            avg_duration: avg_duration,
+            min_duration: min_duration,
+            max_duration: max_duration,
+          }
+        end
+
+        Stats.new(
+          duration: duration,
+          total_requests: total_requests,
+          rate: duration ? format("%.2f", total_requests / duration) : 0,
+          requests: requests
+        ).tap do |stats|
+          # FIXME remove!
+          puts "Calculated stats in #{Time.now - time}s"
+        end
+      end
+
+      def show
+        values = stats
+
+        show_summary(values)
+
+        show_table(values) do |request_values|
+          format(
+            "%-6<method>s %-100<url>s %6<requests>d %12<avg_duration>fs %12<min_duration>fs %12<max_duration>fs",
+            **request_values
+          )
+        end
+      end
+
+      private
+
+      def data
+        synchronize { @data ||= new_data }
+      end
+
+      def data=(values)
+        synchronize { @data = values }
+      end
+
+      def synchronize(&block)
+        @mutex ||= Thread::Mutex.new
+        @mutex.synchronize(&block)
+      end
+
+      def new_data
+        {
+          start: nil,
+          duration: nil,
+          total_requests: 0,
+          steps: [],
+          requests: Hash.new { |h, k| h[k] = [] }
+        }
+      end
+
+      def show_summary(values)
+        puts <<~RESULT
+
+          Lavin results:
+          Test ran for #{values.duration}s
+          Total number of requests: #{values.total_requests}
+          Rate: #{format("%.2f", values.total_requests/values.duration)} rps
+
+        RESULT
+      end
+
+      def show_table(values)
+        puts format(
+          "%-6<method>s %-100<url>s %-6<requests>s %12<avg_duration>s %12<min_duration>s %12<max_duration>s",
+          method: "Method",
+          url: "URL",
+          requests: "Requests",
+          avg_duration: "Avg duration",
+          min_duration: "Min duration",
+          max_duration: "Max duration"
+        )
+
+        divider = "-" * 156
+        puts divider
+        values.each_request { |request_values| puts yield request_values }
+        puts divider
+      end
+    end
+  end
+end

data/lib/lavin/stats.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lavin
+  class Stats
+    attr_reader :duration, :total_requests, :rate, :requests
+
+    def initialize(duration:, total_requests:, rate:, requests: [])
+      @duration = duration
+      @total_requests = total_requests
+      @rate = rate
+      @requests = requests
+    end
+
+    def empty?
+      requests.empty?
+    end
+
+    def to_h
+      {
+        duration:,
+        total_requests:,
+        rate:,
+        requests:
+      }
+    end
+
+    def each_request(&block)
+      requests.each(&block)
+    end
+  end
+end

data/lib/lavin/step.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lavin
+  class Step
+    attr_reader :user, :block, :repeat
+
+    def initialize(repeat: 1, &block)
+      @repeat = repeat
+      @block = block
+    end
+
+    def run(context: nil)
+      repeat.times do
+        call(context:)
+        Runner.yield
+      end
+    end
+
+    def call(context:)
+      context.instance_exec(&block)
+      # Report Success!
+    rescue => error
+      puts "Caught an error - #{error.class}: #{error.message}"
+      puts error.backtrace
+      # Report Failure!
+    end
+  end
+end

data/lib/lavin/user.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "set"
+require "lavin/user_config"
+require "lavin/worker"
+require "lavin/http_client"
+
+module Lavin
+  class User
+    def self.inherited(subclass)
+      super
+      subclass.include UserConfig
+      subclass.include Worker
+      subclass.include HttpClient
+      all_personas << subclass
+    end
+
+    def self.all_personas
+      @all_personas ||= Set.new
+    end
+
+    def self.personas
+      all_personas.select(&:enabled?)
+    end
+
+    attr_reader :user_index
+
+    def initialize(**options)
+      @user_index = options.delete(:user_index)
+    end
+
+    def user_name
+      "#{name}##{user_index}"
+    end
+  end
+end

data/lib/lavin/user_config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Lavin
+  module UserConfig
+    DEFAULT = {
+      enabled: true,
+      user_count: 1,
+      iterations: 1,
+      base_url: nil
+    }.freeze
+
+    module ClassMethods
+      def config
+        @config ||= DEFAULT.dup
+      end
+
+      DEFAULT.each_key do |name|
+        define_method(name) do |value = :no_value_given|
+          current = config.fetch(name) # Make sure the key exist!
+          if value == :no_value_given
+            current
+          else
+            config[name] = value
+          end
+        end
+      end
+
+      def name(value = :no_value_given)
+        if value == :no_value_given
+          @name ||= to_s
+        else
+          @name = value
+        end
+      end
+
+      def description(value = :no_value_given)
+        if value == :no_value_given
+          @description ||= ""
+        else
+          @description = value
+        end
+      end
+
+      def enabled?
+        !!config[:enabled]
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    attr_reader :config
+
+    def initialize(**kwargs)
+      @config = self.class.config
+      super(**kwargs)
+    end
+
+    def name
+      self.class.name
+    end
+
+    def description
+      self.class.description
+    end
+  end
+end

data/lib/lavin/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lavin
+  VERSION = "0.1.0"
+end

data/lib/lavin/web_server.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'lavin/user'
+require 'lavin/statistics'
+
+module Lavin
+  class WebServer < Sinatra::Base
+    set :views, File.expand_path("../../views", __dir__)
+    set :port, 1080
+
+    not_found do
+      erb :not_found, status: 404
+    end
+
+    error do
+      erb :server_error, status: 500, locals: {error: env['sinatra.error']}
+    end
+
+    helpers do
+      def input_type_for(value)
+        case value
+        when Numeric
+          "number"
+        when TrueClass, FalseClass
+          "checkbox"
+        else
+          "text"
+        end
+      end
+    end
+
+    get '/' do
+      erb :index, locals: { personas: Lavin::User.all_personas }
+    end
+
+    post '/start' do
+      Statistics.reset
+      Lavin::Runner.start_async
+      redirect to('/statistics')
+    end
+
+    get '/statistics' do
+      stats = Statistics.stats
+      running = Lavin::Runner.running?
+      if stats.empty? && !running
+        redirect to('/')
+      else
+        erb :statistics, locals: {stats:, running:}
+      end
+    end
+
+    get '/edit' do
+      persona = find_persona
+      raise Sinatra::NotFound unless persona
+
+      erb :edit, locals: {persona:}
+    end
+
+    post '/update_config' do
+      persona = find_persona
+      raise Sinatra::NotFound unless persona
+
+      persona.config.each do |key, old_value|
+        bool = [true, false].include? old_value
+        next unless bool || params.key?(key.to_s)
+
+        new_value = rewrite_config_value(params[key.to_s], old_value)
+        persona.send(key, new_value)
+      end
+
+      redirect to('/')
+    end
+
+    def find_persona(name = nil)
+      name ||= params['persona']
+      Lavin::User.all_personas.find do |persona|
+        persona.name == name
+      end
+    end
+
+    def rewrite_config_value(new_value, old_value)
+      case old_value
+      when TrueClass, FalseClass
+        !!new_value
+      when Integer
+        new_value.to_i
+      when Float
+        new_value.to_f
+      else
+        new_value.to_s
+      end
+    end
+  end
+end

data/lib/lavin/worker.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'lavin/step'
+
+module Lavin
+  module Worker
+    module ClassMethods
+      def before(&block)
+        return @before unless block
+
+        @before = block
+      end
+
+      def after(&block)
+        return @after unless block
+
+        @after = block
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def step(**options, &block)
+        steps << Step.new(**options, &block)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    attr_writer :index
+
+    def initialize(**kwargs)
+      @task = kwargs.delete(:task)
+      super(**kwargs)
+    end
+
+    def run
+      self.class.before.call.then { Runner.yield } if self.class.before
+
+      run_step until finished?
+
+      self.class.after.call.then { Runner.yield } if self.class.after
+    end
+
+    private
+
+    attr_reader :task
+
+    def sleep(seconds)
+      task.sleep seconds
+    end
+
+    def run_step
+      current_step = steps[step_index]
+      self.index += 1
+      current_step&.run(context: self)
+    end
+
+    def steps
+      self.class.steps
+    end
+
+    def index
+      @index ||= 0
+    end
+
+    def step_index
+      index % steps.size
+    end
+
+    def iteration
+      @iteration ||= 0
+    end
+
+    def finished?
+      return false if config[:iterations].negative?
+
+      (index / steps.size) >= config[:iterations]
+    end
+  end
+end

data/lib/lavin.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'debug'
+require 'lavin/version'
+require 'lavin/error'
+require 'lavin/runner'

data.tar.gz.sig

@@ -0,0 +1 @@
+w���r�We��sk�8ƚ�J�A��sl���k*�z
4��\��w�x

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: lavin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sammy Henningsson
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDVjCCAj6gAwIBAgIBATANBgkqhkiG9w0BAQsFADAqMSgwJgYDVQQDDB9zYW1t
+  eS5oZW5uaW5nc3Nvbi9EQz1oZXkvREM9Y29tMB4XDTIyMDEzMTIwNTQxMloXDTI0
+  MDEzMTIwNTQxMlowKjEoMCYGA1UEAwwfc2FtbXkuaGVubmluZ3Nzb24vREM9aGV5
+  L0RDPWNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK+SDC1mfyhu
+  cJ6Va21rIHUGscEtQrdvyBqxFG1s2TgPMAv4RbqwdJVPa7kjtbCzslADlUE1oru2
+  C+rcJsMtVGX02ukMIPHT1OjTyy0/EMqLqSy3WeRI8APyDSxCVbe+h5BMf3zZnYfd
+  dR6AeG7ln09T1P/tX+9lTMc+I+DW1fUlQgY48CNUayvtJR61svXvXMrhLhi29SQi
+  g1qmH6Zoe22/JgH+m2JksPndY5Ep3gqfDc6Imwu2vGvmGErJD63FB0XQ/wb4WVH4
+  l7sHQSTfKDp8SImCt1xqNgIyjw578ZG2geGLoncuxgDrbQ/UFIJ11lDZd4vLevMh
+  nIxTSJpPr2cCAwEAAaOBhjCBgzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNV
+  HQ4EFgQUukjj1Cd2ea6IOHDLZe0ymzs2jWkwJAYDVR0RBB0wG4EZc2FtbXkuaGVu
+  bmluZ3Nzb25AaGV5LmNvbTAkBgNVHRIEHTAbgRlzYW1teS5oZW5uaW5nc3NvbkBo
+  ZXkuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQCNUrjx1+L5W9R5O5MF3fnnNIyxOXGa
+  qzqpmXpTd7pHUGvSzVxYM/NIkUHSSPyxLAG+RYMPJHjDOSzhLmOUbgpfOsQ8sqUP
+  plABBC03e/+oDwFwlHefonil+sp/AOT9TYZJQbShjKt3/X+VGzjtujJZwvKgiiP0
+  Ht5Q4dvW1ZqUZgvXdYM1LnCX7I3WjoRyhOwdSlaEz5gnD+KYewHiiByK1Jv2n0PG
+  DVzXaUnsmwP+jQ1PkDa5q8ibBzMd2c6Hmm87UDqPxZtML0bF9SjrpbyLMjwtXaMA
+  WDPp0ajpdUZ9GPHsrVNYXiOfQIqcmlmpYVsH1o7vuneUIcIDMrnMDChh
+  -----END CERTIFICATE-----
+date: 2022-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description:
+email:
+- sammy.henningsson@hemnet.se
+executables:
+- lavin
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/lavin
+- lib/lavin.rb
+- lib/lavin/client.rb
+- lib/lavin/error.rb
+- lib/lavin/http_client.rb
+- lib/lavin/runner.rb
+- lib/lavin/statistics.rb
+- lib/lavin/stats.rb
+- lib/lavin/step.rb
+- lib/lavin/user.rb
+- lib/lavin/user_config.rb
+- lib/lavin/version.rb
+- lib/lavin/web_server.rb
+- lib/lavin/worker.rb
+homepage: https://github.com/sammyhenningsson/lavin
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sammyhenningsson/lavin
+  source_code_uri: https://github.com/sammyhenningsson/lavin
+  changelog_uri: https://github.com/sammyhenningsson/lavin/CHANGELOG
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A framework for loadtesting sites.
+test_files: []