toxiproxy 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2f83e60344122fe413e11816f5c976e46de7d6e
+  data.tar.gz: 52de814ecc4b5c472329179daf349599c9a5d15a
+SHA512:
+  metadata.gz: 1ae9818932feabbb5982eb525d7dcfd1a03d20047d0e99d2cbd07e3b62d474285e118a29505802571c8132f595a5c014e0bf9327e9a0a6f8358db2836e37f8cb
+  data.tar.gz: a58e9df0b31c788e9b927fdf7c399621dce64e4f9dcb83e9670ea87ddcfe230a05eb2f3f2be29cf83e23d56ef2e5675a62f6210d66c1006030712cc34a654d36

data/.gitignore

@@ -0,0 +1,3 @@
+vendor/
+.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Shopify
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,50 @@
+# toxiproxy-ruby
+
+[Toxiproxy](https://github.com/shopify/toxiproxy) is a proxy to simulate network
+and system conditions. The Ruby API aims to make it simple to write tests that
+assure your application behaves appropriate under harsh conditions. Please see
+the Toxiproxy project for more details.
+
+```
+gem install toxiproxy
+```
+
+Make sure the Toxiproxy server is already running.
+
+## Usage
+
+For example, to simulate 1000ms latency on a database server you can use the
+`latency` toxic with the `latency` argument (see the Toxiproxy project for a
+list of all toxics):
+
+```ruby
+Toxiproxy[:mysql_master].downstream(:latency, latency: 1000) do
+  Shop.first # this took at least 1s
+end
+```
+
+You can also take an endpoint down for the duration of a block at the TCP level:
+
+```ruby
+Toxiproxy[:mysql_master].down do
+  Shop.first # this'll raise
+end
+```
+
+If you want to simulate all your Redis instances being down:
+
+```ruby
+Toxiproxy[/redis/].down do
+  # any redis call will fail
+end
+```
+
+If you want to simulate that your cache server is slow at incoming network
+(upstream), but fast at outgoing (downstream), you can apply a toxic to just the
+upstream:
+
+```ruby
+Toxiproxy[:cache].upstream(:latency, latency: 1000) do
+  Cache.get(:omg) # will take at least a second
+end
+```

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end

data/bin/start-toxiproxy.sh

@@ -0,0 +1,8 @@
+#!/bin/bash -e
+
+VERSION='fad1365c087d6ad53944c8201a6131cb'
+
+echo "[start toxiproxy]"
+curl --silent http://shopify-vagrant.s3.amazonaws.com/toxiproxy/toxiproxy-$VERSION -o ./bin/toxiproxy
+chmod +x ./bin/toxiproxy
+nohup bash -c "./bin/toxiproxy > ${CIRCLE_ARTIFACTS}/toxiproxy.log 2>&1 &"

data/circle.yml

@@ -0,0 +1,7 @@
+dependencies:
+  override:
+    - bundle install
+    - ./bin/start-toxiproxy.sh
+test:
+  override:
+    - bundle exec rake test

data/lib/toxiproxy.rb

@@ -0,0 +1,179 @@
+require "json"
+require "uri"
+require "net/http"
+
+require "toxiproxy/collection"
+require "toxiproxy/toxic"
+require "toxiproxy/toxic_collection"
+
+class Toxiproxy
+  URI = ::URI.parse("http://127.0.0.1:8474")
+  VALID_DIRECTIONS = [:upstream, :downstream]
+
+  class NotFound < StandardError; end
+  class ProxyExists < StandardError; end
+  class InvalidToxic < StandardError; end
+
+  attr_reader :listen, :name
+
+  def initialize(options)
+    @upstream = options[:upstream]
+    @listen   = options[:listen] || "localhost:0"
+    @name     = options[:name]
+  end
+
+  # Forwardable doesn't support delegating class methods, so we resort to
+  # `define_method` to delegate from Toxiproxy to #all, and from there to the
+  # proxy collection.
+  class << self
+    Collection::METHODS.each do |method|
+      define_method(method) do |*args, &block|
+        self.all.send(method, *args, &block)
+      end
+    end
+  end
+
+  # Returns a collection of all currently active Toxiproxies.
+  def self.all
+    request = Net::HTTP::Get.new("/proxies")
+    response = http.request(request)
+    assert_response(response)
+
+    proxies = JSON.parse(response.body).map { |name, attrs|
+      self.new({
+        upstream: attrs["upstream"],
+        listen: attrs["listen"],
+        name: attrs["name"]
+      })
+    }
+
+    Collection.new(proxies)
+  end
+
+  # Convenience method to create a proxy.
+  def self.create(options)
+    self.new(options).create
+  end
+
+  # Find a single proxy by name.
+  def self.find_by_name(name = nil, &block)
+    proxy = self.all.find { |p| p.name == name.to_s }
+    raise NotFound, "#{name} not found in #{self.all.map(&:name).join(', ')}" unless proxy
+    proxy
+  end
+
+  # If given a regex, it'll use `grep` to return a Toxiproxy::Collection.
+  # Otherwise, it'll convert the passed object to a string and find the proxy by
+  # name.
+  def self.[](query)
+    return grep(query) if query.is_a?(Regexp)
+    find_by_name(query)
+  end
+
+  # Set an upstream toxic.
+  def upstream(toxic = nil, attrs = {})
+    return @upstream unless toxic
+
+    collection = ToxicCollection.new(self)
+    collection.upstream(toxic, attrs)
+    collection
+  end
+
+  # Set a downstream toxic.
+  def downstream(toxic, attrs = {})
+    collection = ToxicCollection.new(self)
+    collection.downstream(toxic, attrs)
+    collection
+  end
+
+  # Simulates the endpoint is down, by closing the connection and no
+  # longer accepting connections. This is useful to simulate critical system
+  # failure, such as a data store becoming completely unavailable.
+  def down(&block)
+    uptoxics = toxics(:upstream)
+    downtoxics = toxics(:downstream)
+    destroy
+    begin
+      yield
+    ensure
+      create
+      uptoxics.each(&:save)
+      downtoxics.each(&:save)
+    end
+  end
+
+  # Create a Toxiproxy, proxying traffic from `@listen` (optional argument to
+  # the constructor) to `@upstream`. `#down` `#upstream` or `#downstream` can at any time alter the health
+  # of this connection.
+  def create
+    request = Net::HTTP::Post.new("/proxies")
+
+    hash = {upstream: upstream, name: name, listen: listen}
+    request.body = hash.to_json
+
+    response = http.request(request)
+    assert_response(response)
+
+    new = JSON.parse(response.body)
+    @listen = new["listen"]
+
+    self
+  end
+
+  # Destroys a Toxiproxy.
+  def destroy
+    request = Net::HTTP::Delete.new("/proxies/#{name}")
+    response = http.request(request)
+    assert_response(response)
+    self
+  end
+
+  private
+
+  # Returns a collection of the current toxics for a direction.
+  def toxics(direction)
+    unless VALID_DIRECTIONS.include?(direction.to_sym)
+      raise InvalidToxic, "Toxic direction must be one of: [#{VALID_DIRECTIONS.join(', ')}], got: #{direction}"
+    end
+
+    request = Net::HTTP::Get.new("/proxies/#{name}/#{direction}/toxics")
+    response = http.request(request)
+    assert_response(response)
+
+    toxics = JSON.parse(response.body).map { |name, attrs|
+      Toxic.new({
+        name: name,
+        proxy: self,
+        direction: direction,
+        attrs: attrs
+      })
+    }
+
+    toxics
+  end
+
+  def self.http
+    @http ||= Net::HTTP.new(URI.host, URI.port)
+  end
+
+  def http
+    self.class.http
+  end
+
+  def self.assert_response(response)
+    case response
+    when Net::HTTPConflict
+      raise Toxiproxy::ProxyExists, response.body
+    when Net::HTTPNotFound
+      raise Toxiproxy::NotFound, response.body
+    when Net::HTTPBadRequest
+      raise Toxiproxy::InvalidToxic, response.body
+    else
+      response.value # raises if not OK
+    end
+  end
+
+  def assert_response(*args)
+    self.class.assert_response(*args)
+  end
+end

data/lib/toxiproxy/collection.rb

@@ -0,0 +1,58 @@
+require "forwardable"
+
+class Toxiproxy
+  # ProxyCollection represents a set of proxies. This allows to easily perform
+  # actions on every proxy in the collection.
+  #
+  # Unfortunately, it doesn't implement all of Enumerable because there's no way
+  # to subclass an Array or include Enumerable for the methods to return a
+  # Collection instead of an Array (see MRI). Instead, we delegate methods where
+  # it doesn't matter and only allow the filtering methods that really make
+  # sense on a proxy collection.
+  class Collection
+    extend Forwardable
+
+    DELEGATED_METHODS = [:length, :size, :count, :find, :each, :map]
+    DEFINED_METHODS   = [:select, :reject, :grep, :down]
+    METHODS = DEFINED_METHODS + DELEGATED_METHODS
+
+    def_delegators :@collection, *DELEGATED_METHODS
+
+    def initialize(collection)
+      @collection = collection
+    end
+
+    # Sets every proxy in the collection as down. For example:
+    #
+    #   Toxiproxy.grep(/redis/).down { .. }
+    #
+    # Would simulate every Redis server being down for the duration of the
+    # block.
+    def down(*args, &block)
+      @collection.inject(block) { |nested, proxy|
+        -> { proxy.down(*args, &nested) }
+      }.call
+    end
+
+    # Destroys all toxiproxy's in the collection
+    def destroy
+      @collection.each(&:destroy)
+    end
+
+    def select(&block)
+      self.class.new(@collection.select(&block))
+    end
+
+    def reject(&block)
+      self.class.new(@collection.reject(&block))
+    end
+
+    # Grep allows easily selecting a subset of proxies, by returning a
+    # ProxyCollection with every proxy name matching the regex passed.
+    def grep(regex)
+      self.class.new(@collection.select { |proxy|
+        proxy.name =~ regex
+      })
+    end
+  end
+end

data/lib/toxiproxy/toxic.rb

@@ -0,0 +1,47 @@
+class Toxiproxy
+  class Toxic
+    attr_reader :name, :proxy, :direction
+    attr_reader :attrs
+
+    def initialize(options)
+      @proxy     = options[:proxy]
+      @name      = options[:name]
+      @direction = options[:direction]
+      @attrs     = options[:attrs] || {}
+    end
+
+    def enabled?
+      attrs[:enabled]
+    end
+
+    def enable
+      attrs[:enabled] = true
+      save
+    end
+
+    def disable
+      attrs[:enabled] = false
+      save
+    end
+
+    def []=(name, value)
+      attrs[name] = value
+    end
+
+    def save
+      unless VALID_DIRECTIONS.include?(direction.to_sym)
+        raise InvalidToxic, "Toxic direction must be one of: [#{VALID_DIRECTIONS.join(', ')}], got: #{direction}"
+      end
+      request = Net::HTTP::Post.new("/proxies/#{proxy.name}/#{direction}/toxics/#{name}")
+
+      request.body = attrs.to_json
+
+      response = Toxiproxy.http.request(request)
+      Toxiproxy.assert_response(response)
+
+      @attrs = JSON.parse(response.body)
+
+      self
+    end
+  end
+end

data/lib/toxiproxy/toxic_collection.rb

@@ -0,0 +1,42 @@
+class Toxiproxy
+  class ToxicCollection
+    extend Forwardable
+
+    attr_accessor :toxics
+    attr_reader :proxy
+
+    def_delegators :@toxics, :<<, :find
+
+    def initialize(proxy)
+      @proxy  = proxy
+      @toxics = []
+    end
+
+    def apply(&block)
+      @toxics.each(&:enable)
+      yield
+    ensure
+      @toxics.each(&:disable)
+    end
+
+    def upstream(toxic_name, attrs = {})
+      toxics << Toxic.new(
+        name: toxic_name,
+        proxy: proxy,
+        direction: :upstream,
+        attrs: attrs
+      )
+      self
+    end
+
+    def downstream(toxic_name, attrs = {})
+      toxics << Toxic.new(
+        name: toxic_name,
+        proxy: proxy,
+        direction: :downstream,
+        attrs: attrs
+      )
+      self
+    end
+  end
+end

data/lib/toxiproxy/version.rb

@@ -0,0 +1,3 @@
+class Toxiproxy
+  VERSION = "0.0.2"
+end

data/shipit.rubygems.yml

@@ -0,0 +1,2 @@
+fetch:
+  - fetch-gem-version toxiproxy Shopify/toxiproxy-ruby

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest'
+require 'minitest/autorun'
+require_relative "../lib/toxiproxy"

data/test/toxiproxy_test.rb

@@ -0,0 +1,209 @@
+require 'test_helper'
+
+class ToxiproxyTest < MiniTest::Unit::TestCase
+  def teardown
+    Toxiproxy.grep(/\Atest_/).each(&:destroy)
+  end
+
+  def test_create_proxy
+    proxy = Toxiproxy.create(upstream: "localhost:3306", name: "test_mysql_master")
+
+    assert_equal "localhost:3306", proxy.upstream
+    assert_equal "test_mysql_master", proxy.name
+  end
+
+  def test_create_and_find_proxy
+    proxy = Toxiproxy.create(upstream: "localhost:3306", name: "test_mysql_master")
+
+    assert_equal "localhost:3306", proxy.upstream
+    assert_equal "test_mysql_master", proxy.name
+
+    proxy = Toxiproxy[:test_mysql_master]
+
+    assert_equal "localhost:3306", proxy.upstream
+    assert_equal "test_mysql_master", proxy.name
+  end
+
+  def test_take_endpoint_down
+    with_tcpserver do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
+      listen_addr = proxy.listen
+
+      proxy.down do
+        assert_proxy_unavailable proxy
+      end
+
+      assert_proxy_available proxy
+
+      assert_equal listen_addr, proxy.listen
+    end
+  end
+
+  def test_raises_when_proxy_doesnt_exist
+    assert_raises Toxiproxy::NotFound do
+      Toxiproxy[:does_not_exist]
+    end
+  end
+
+  def test_proxies_all_returns_proxy_collection
+    assert_instance_of Toxiproxy::Collection, Toxiproxy.all
+  end
+
+  def test_down_on_proxy_collection_disables_entire_collection
+    with_tcpserver do |port1|
+      with_tcpserver do |port2|
+        proxy1 = Toxiproxy.create(upstream: "localhost:#{port1}", name: "test_proxy1")
+        proxy2 = Toxiproxy.create(upstream: "localhost:#{port2}", name: "test_proxy2")
+
+        assert_proxy_available proxy2
+        assert_proxy_available proxy1
+
+        Toxiproxy.all.down do
+          assert_proxy_unavailable proxy1
+          assert_proxy_unavailable proxy2
+        end
+
+        assert_proxy_available proxy2
+        assert_proxy_available proxy1
+      end
+    end
+  end
+
+  def test_select_from_toxiproxy_collection
+    with_tcpserver do |port|
+      Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxies = Toxiproxy.select { |p| p.upstream == "localhost:#{port}" }
+
+      assert_equal 1, proxies.size
+      assert_instance_of Toxiproxy::Collection, proxies
+    end
+  end
+
+  def test_grep_returns_toxiproxy_collection
+    with_tcpserver do |port|
+      Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxies = Toxiproxy.grep(/\Atest/)
+
+      assert_equal 1, proxies.size
+      assert_instance_of Toxiproxy::Collection, proxies
+    end
+  end
+
+  def test_indexing_allows_regexp
+    with_tcpserver do |port|
+      Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxies = Toxiproxy[/\Atest/]
+
+      assert_equal 1, proxies.size
+      assert_instance_of Toxiproxy::Collection, proxies
+    end
+  end
+
+  def test_apply_upstream_toxic
+    $before = Time.now
+
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxy.upstream(:latency, latency: 100).apply do
+        before = Time.now
+
+        socket = connect_to_proxy(proxy)
+        socket.write("omg\n")
+        socket.flush
+        socket.gets
+
+        passed = Time.now - before
+
+        assert_in_delta passed, 0.100, 0.01
+      end
+    end
+  end
+
+  def test_apply_downstream_toxic
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxy.downstream(:latency, latency: 100).apply do
+        before = Time.now
+
+        socket = connect_to_proxy(proxy)
+        socket.write("omg\n")
+        socket.flush
+        socket.gets
+
+        passed = Time.now - before
+
+        assert_in_delta passed, 0.100, 0.01
+      end
+    end
+  end
+
+  def test_apply_prolong_toxics
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxy.upstream(:latency, latency: 100).downstream(:latency, latency: 100).apply do
+        before = Time.now
+
+        socket = connect_to_proxy(proxy)
+        socket.write("omg\n")
+        socket.flush
+        socket.gets
+
+        passed = Time.now - before
+
+        assert_in_delta passed, 0.200, 0.01
+      end
+    end
+  end
+
+  private
+
+  def assert_proxy_available(proxy)
+    connect_to_proxy proxy
+  end
+
+  def assert_proxy_unavailable(proxy)
+    assert_raises Errno::ECONNREFUSED do
+      connect_to_proxy proxy
+    end
+  end
+
+  def connect_to_proxy(proxy)
+    TCPSocket.new(*proxy.listen.split(":".freeze))
+  end
+
+  def with_tcpserver(receive = false, &block)
+    mon = Monitor.new
+    cond = mon.new_cond
+    port = nil
+
+    thread = Thread.new {
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+      mon.synchronize { cond.signal }
+      loop do
+        client = server.accept
+
+        if receive
+          client.gets
+          client.write("omgs\n")
+          client.flush
+        end
+
+        client.close
+      end
+      server.close
+    }
+
+    mon.synchronize { cond.wait }
+
+    yield(port)
+  ensure
+    thread.kill
+  end
+end

data/toxiproxy.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path("../lib/toxiproxy/version", __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name = "toxiproxy"
+  spec.version = Toxiproxy::VERSION
+  spec.authors = ["Simon Eskildsen", "Jacob Wirth"]
+  spec.email = "simon.eskildsen@shopify.com"
+  spec.summary = "Ruby library for Toxiproxy"
+  spec.description = "A Ruby library for controlling Toxiproxy. Can be used in resiliency testing."
+  spec.homepage = "https://github.com/Shopify/toxiproxy"
+  spec.license = "MIT"
+
+  spec.files = `git ls-files`.split("\n")
+  spec.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: toxiproxy
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Simon Eskildsen
+- Jacob Wirth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby library for controlling Toxiproxy. Can be used in resiliency testing.
+email: simon.eskildsen@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/start-toxiproxy.sh
+- circle.yml
+- lib/toxiproxy.rb
+- lib/toxiproxy/collection.rb
+- lib/toxiproxy/toxic.rb
+- lib/toxiproxy/toxic_collection.rb
+- lib/toxiproxy/version.rb
+- shipit.rubygems.yml
+- test/test_helper.rb
+- test/toxiproxy_test.rb
+- toxiproxy.gemspec
+homepage: https://github.com/Shopify/toxiproxy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby library for Toxiproxy
+test_files:
+- test/test_helper.rb
+- test/toxiproxy_test.rb