toxiproxy 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2f83e60344122fe413e11816f5c976e46de7d6e
-  data.tar.gz: 52de814ecc4b5c472329179daf349599c9a5d15a
+  metadata.gz: 75c5cd8a2dd3d9a8f0b932d7f50e0359c77c0fda
+  data.tar.gz: a6585a9edf06bc9888943292d8784c8aab61685c
 SHA512:
-  metadata.gz: 1ae9818932feabbb5982eb525d7dcfd1a03d20047d0e99d2cbd07e3b62d474285e118a29505802571c8132f595a5c014e0bf9327e9a0a6f8358db2836e37f8cb
-  data.tar.gz: a58e9df0b31c788e9b927fdf7c399621dce64e4f9dcb83e9670ea87ddcfe230a05eb2f3f2be29cf83e23d56ef2e5675a62f6210d66c1006030712cc34a654d36
+  metadata.gz: 11f4d1e556c4f942838e3c7d7484e25ed6defecb77985d4609739f25ec383c51aa07c505f64313fb197cfac96611d8ab97d688f6bb8a09a2169112acdf0e763b
+  data.tar.gz: 87df2064d0189804a8e84820304a5a9312c767b1337bf3d7941c9ea929bdbaa25de654188ba8cdf9d0a361e0087c86ce5a096c428ec0f1d4b7d073a019f218c6

data/README.md

@@ -2,8 +2,9 @@
 
 [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.
+ensure your application behaves appropriately under harsh conditions. Before you
+can use the Ruby library, you need to read the [Usage section of the Toxiproxy
+README](https://githubcom/shopify/toxiproxy#Usage).
 
 ```
 gem install toxiproxy
@@ -11,14 +12,19 @@ gem install toxiproxy
 
 Make sure the Toxiproxy server is already running.
 
+For more information about Toxiproxy and the available toxics, see the [Toxiproxy
+documentation](https://github.com/shopify/toxiproxy)
+
 ## Usage
 
+The Ruby client communicates with the Toxiproxy daemon via HTTP.
+
 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
+Toxiproxy[:mysql_master].downstream(:latency, latency: 1000).apply do
   Shop.first # this took at least 1s
 end
 ```
@@ -44,7 +50,25 @@ If you want to simulate that your cache server is slow at incoming network
 upstream:
 
 ```ruby
-Toxiproxy[:cache].upstream(:latency, latency: 1000) do
+Toxiproxy[:cache].upstream(:latency, latency: 1000).apply do
   Cache.get(:omg) # will take at least a second
 end
 ```
+
+You can apply many toxics to many connections:
+
+```ruby
+Toxiproxy[/redis/].upstream(:slow_close, delay: 100).downstream(:latency, jitter: 300).apply do
+  # all redises are now slow at responding and closing
+end
+
+## Populate
+
+To populate Toxiproxy with the proxies from `config/toxiproxy.json`:
+
+```ruby
+Toxiproxy.populate("./config/toxiproxy.json")
+```
+
+It's recommended to do this early as early in boot as possible, see the
+[Toxiproxy README](https://github.com/shopify/toxiproxy#Usage)..

data/bin/start-toxiproxy.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -e
 
-VERSION='fad1365c087d6ad53944c8201a6131cb'
+VERSION='0eef7f44653b07ee0e0f8de1cc64b09a'
 
 echo "[start toxiproxy]"
 curl --silent http://shopify-vagrant.s3.amazonaws.com/toxiproxy/toxiproxy-$VERSION -o ./bin/toxiproxy

data/lib/toxiproxy/collection.rb

@@ -28,12 +28,36 @@ class Toxiproxy
     #
     # Would simulate every Redis server being down for the duration of the
     # block.
-    def down(*args, &block)
+    def down(&block)
       @collection.inject(block) { |nested, proxy|
-        -> { proxy.down(*args, &nested) }
+        -> { proxy.down(&nested) }
       }.call
     end
 
+    # Set an upstream toxic.
+    def upstream(toxic, attrs = {})
+      toxics = ToxicCollection.new(@collection)
+      toxics.upstream(toxic, attrs)
+      toxics
+    end
+
+    # Set a downstream toxic.
+    def downstream(toxic, attrs = {})
+      toxics = ToxicCollection.new(@collection)
+      toxics.downstream(toxic, attrs)
+      toxics
+    end
+
+    # Disables all proxies in the collection.
+    def disable
+      @collection.each(&:disable)
+    end
+
+    # Enables all proxies in the collection.
+    def enable
+      @collection.each(&:enable)
+    end
+
     # Destroys all toxiproxy's in the collection
     def destroy
       @collection.each(&:destroy)

data/lib/toxiproxy/toxic.rb

@@ -11,19 +11,23 @@ class Toxiproxy
     end
 
     def enabled?
-      attrs[:enabled]
+      attrs['enabled']
     end
 
     def enable
-      attrs[:enabled] = true
+      attrs['enabled'] = true
       save
     end
 
     def disable
-      attrs[:enabled] = false
+      attrs['enabled'] = false
       save
     end
 
+    def [](name)
+      attrs[name]
+    end
+
     def []=(name, value)
       attrs[name] = value
     end

data/lib/toxiproxy/toxic_collection.rb

@@ -3,12 +3,12 @@ class Toxiproxy
     extend Forwardable
 
     attr_accessor :toxics
-    attr_reader :proxy
+    attr_reader :proxies
 
     def_delegators :@toxics, :<<, :find
 
-    def initialize(proxy)
-      @proxy  = proxy
+    def initialize(proxies)
+      @proxies = proxies
       @toxics = []
     end
 
@@ -20,22 +20,26 @@ class Toxiproxy
     end
 
     def upstream(toxic_name, attrs = {})
-      toxics << Toxic.new(
-        name: toxic_name,
-        proxy: proxy,
-        direction: :upstream,
-        attrs: attrs
-      )
+      proxies.each do |proxy|
+        toxics << Toxic.new(
+          name: toxic_name,
+          proxy: proxy,
+          direction: :upstream,
+          attrs: attrs
+        )
+      end
       self
     end
 
     def downstream(toxic_name, attrs = {})
-      toxics << Toxic.new(
-        name: toxic_name,
-        proxy: proxy,
-        direction: :downstream,
-        attrs: attrs
-      )
+      proxies.each do |proxy|
+        toxics << Toxic.new(
+          name: toxic_name,
+          proxy: proxy,
+          direction: :downstream,
+          attrs: attrs
+        )
+      end
       self
     end
   end

data/lib/toxiproxy/version.rb

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

data/lib/toxiproxy.rb

@@ -14,12 +14,13 @@ class Toxiproxy
   class ProxyExists < StandardError; end
   class InvalidToxic < StandardError; end
 
-  attr_reader :listen, :name
+  attr_reader :listen, :name, :enabled
 
   def initialize(options)
     @upstream = options[:upstream]
     @listen   = options[:listen] || "localhost:0"
     @name     = options[:name]
+    @enabled  = options[:enabled]
   end
 
   # Forwardable doesn't support delegating class methods, so we resort to
@@ -33,6 +34,14 @@ class Toxiproxy
     end
   end
 
+  # Re-enables all proxies and disables all toxics.
+  def self.reset
+    request = Net::HTTP::Get.new("/reset")
+    response = http.request(request)
+    assert_response(response)
+    self
+  end
+
   # Returns a collection of all currently active Toxiproxies.
   def self.all
     request = Net::HTTP::Get.new("/proxies")
@@ -43,7 +52,8 @@ class Toxiproxy
       self.new({
         upstream: attrs["upstream"],
         listen: attrs["listen"],
-        name: attrs["name"]
+        name: attrs["name"],
+        enabled: attrs["enabled"]
       })
     }
 
@@ -57,7 +67,12 @@ class Toxiproxy
 
   # Find a single proxy by name.
   def self.find_by_name(name = nil, &block)
-    proxy = self.all.find { |p| p.name == name.to_s }
+    self.all.find { |p| p.name == name.to_s }
+  end
+
+  # Calls find_by_name and raises NotFound if not found
+  def self.find_by_name!(*args)
+    proxy = find_by_name(*args)
     raise NotFound, "#{name} not found in #{self.all.map(&:name).join(', ')}" unless proxy
     proxy
   end
@@ -67,21 +82,30 @@ class Toxiproxy
   # name.
   def self.[](query)
     return grep(query) if query.is_a?(Regexp)
-    find_by_name(query)
+    find_by_name!(query)
+  end
+
+  def self.populate(path)
+    proxies = JSON.parse(File.read(path), symbolize_names: true)
+    proxies = proxies.map { |proxy| self.new(proxy) }
+
+    proxies.each do |proxy|
+      proxy.create unless find_by_name(proxy.name)
+    end
   end
 
   # Set an upstream toxic.
   def upstream(toxic = nil, attrs = {})
     return @upstream unless toxic
 
-    collection = ToxicCollection.new(self)
+    collection = ToxicCollection.new([self])
     collection.upstream(toxic, attrs)
     collection
   end
 
   # Set a downstream toxic.
   def downstream(toxic, attrs = {})
-    collection = ToxicCollection.new(self)
+    collection = ToxicCollection.new([self])
     collection.downstream(toxic, attrs)
     collection
   end
@@ -90,25 +114,45 @@ class Toxiproxy
   # 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
+    disable
     begin
       yield
     ensure
-      create
-      uptoxics.each(&:save)
-      downtoxics.each(&:save)
+      enable
     end
   end
 
+  # Disables a Toxiproxy. This will drop all active connections and stop the proxy from listening.
+  def disable
+    request = Net::HTTP::Post.new("/proxies/#{name}")
+
+    hash = {enabled: false}
+    request.body = hash.to_json
+
+    response = http.request(request)
+    assert_response(response)
+    self
+  end
+
+  # Enables a Toxiproxy. This will cause the proxy to start listening again.
+  def enable
+    request = Net::HTTP::Post.new("/proxies/#{name}")
+
+    hash = {enabled: true}
+    request.body = hash.to_json
+
+    response = http.request(request)
+    assert_response(response)
+    self
+  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}
+    hash = {upstream: upstream, name: name, listen: listen, enabled: enabled}
     request.body = hash.to_json
 
     response = http.request(request)
@@ -128,8 +172,6 @@ class Toxiproxy
     self
   end
 
-  private
-
   # Returns a collection of the current toxics for a direction.
   def toxics(direction)
     unless VALID_DIRECTIONS.include?(direction.to_sym)
@@ -152,6 +194,8 @@ class Toxiproxy
     toxics
   end
 
+  private
+
   def self.http
     @http ||= Net::HTTP.new(URI.host, URI.port)
   end

data/test/fixtures/toxiproxy.json

@@ -0,0 +1,7 @@
+[
+  {
+    "name": "toxiproxy_test_mysql",
+    "upstream": "localhost:3306",
+    "listen": "localhost:22222"
+  }
+]

data/test/toxiproxy_test.rb

@@ -24,6 +24,57 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     assert_equal "test_mysql_master", proxy.name
   end
 
+  def test_enable_and_disable_proxy
+    with_tcpserver do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
+      listen_addr = proxy.listen
+
+      Toxiproxy::Toxic.new(
+        name: 'latency',
+        proxy: proxy,
+        direction: :upstream,
+        attrs: {'latency' => 123}
+      ).enable
+
+      proxy.disable
+      assert_proxy_unavailable proxy
+      proxy.enable
+      assert_proxy_available proxy
+
+      latency = proxy.toxics(:upstream).find { |toxic| toxic.name == 'latency' }
+      assert_equal 123, latency['latency']
+      assert latency.enabled?
+
+      assert_equal listen_addr, proxy.listen
+    end
+  end
+
+  def test_reset
+    with_tcpserver do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
+      listen_addr = proxy.listen
+
+      proxy.disable
+      assert_proxy_unavailable proxy
+
+      Toxiproxy::Toxic.new(
+        name: 'latency',
+        proxy: proxy,
+        direction: :upstream,
+        attrs: {'latency' => 125}
+      ).enable
+
+      Toxiproxy.reset
+      assert_proxy_available proxy
+
+      latency = proxy.toxics(:upstream).find { |toxic| toxic.name == 'latency' }
+      assert_equal 125, latency['latency']
+      assert !latency.enabled?
+
+      assert_equal listen_addr, proxy.listen
+    end
+  end
+
   def test_take_endpoint_down
     with_tcpserver do |port|
       proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
@@ -69,6 +120,26 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_disable_on_proxy_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.disable
+        assert_proxy_unavailable proxy1
+        assert_proxy_unavailable proxy2
+        Toxiproxy.all.enable
+
+        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")
@@ -103,8 +174,6 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
   end
 
   def test_apply_upstream_toxic
-    $before = Time.now
-
     with_tcpserver(receive: true) do |port|
       proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
 
@@ -161,6 +230,47 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_apply_toxics_to_collection
+    with_tcpserver(receive: true) do |port1|
+      with_tcpserver(receive: true) do |port2|
+        proxy1 = Toxiproxy.create(upstream: "localhost:#{port1}", name: "test_proxy1")
+        proxy2 = Toxiproxy.create(upstream: "localhost:#{port2}", name: "test_proxy2")
+
+        Toxiproxy[/test_proxy/].upstream(:latency, latency: 100).downstream(:latency, latency: 100).apply do
+          before = Time.now
+
+          socket = connect_to_proxy(proxy1)
+          socket.write("omg\n")
+          socket.flush
+          socket.gets
+
+          passed = Time.now - before
+
+          assert_in_delta passed, 0.200, 0.01
+
+          before = Time.now
+
+          socket = connect_to_proxy(proxy2)
+          socket.write("omg\n")
+          socket.flush
+          socket.gets
+
+          passed = Time.now - before
+
+          assert_in_delta passed, 0.200, 0.01
+        end
+      end
+    end
+  end
+
+  def test_populate_creates_proxies
+    proxies = Toxiproxy.populate("./test/fixtures/toxiproxy.json")
+
+    proxies.each do |proxy|
+      assert_proxy_available(proxy)
+    end
+  end
+
   private
 
   def assert_proxy_available(proxy)

metadata

@@ -1,15 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: toxiproxy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Simon Eskildsen
 - Jacob Wirth
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2014-11-07 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MQ8wDQYDVQQDDAZhZG1p
+  bnMxFzAVBgoJkiaJk/IsZAEZFgdzaG9waWZ5MRMwEQYKCZImiZPyLGQBGRYDY29t
+  MB4XDTE0MDUxNTIwMzM0OFoXDTE1MDUxNTIwMzM0OFowPzEPMA0GA1UEAwwGYWRt
+  aW5zMRcwFQYKCZImiZPyLGQBGRYHc2hvcGlmeTETMBEGCgmSJomT8ixkARkWA2Nv
+  bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL0/81O3e1vh5smcwp2G
+  MpLQ6q0kejQLa65bPYPxdzWA1SYOKyGfw+yR9LdFzsuKpwWzKq6zX35lj1IckWS4
+  bNBEQzxmufUxU0XPM02haFB8fOfDJzdXsWte9Ge4IFwahwn68gpMqN+BvxL+KMYz
+  Iut9YmN44d4LZdsENEIO5vmybuG2vYDz7R56qB0PA+Q2P2CdhymsBad2DQs69FBo
+  uico9V6VMYYctL9lCYdzu9IXrOYNTt88suKIVzzAlHOKeN0Ng5qdztFoTR8sfxDr
+  Ydg3KHl5n47wlpgd8R0f/4b5gGxW+v9pyJCgQnLlRu7DedVSvv7+GMtj3g9r3nhJ
+  KqECAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFI/o
+  maf34HXbUOQsdoLHacEKQgunMB0GA1UdEQQWMBSBEmFkbWluc0BzaG9waWZ5LmNv
+  bTAdBgNVHRIEFjAUgRJhZG1pbnNAc2hvcGlmeS5jb20wDQYJKoZIhvcNAQEFBQAD
+  ggEBADkK9aj5T0HPExsov4EoMWFnO+G7RQ28C30VAfKxnL2UxG6i4XMHVs6Xi94h
+  qXFw1ec9Y2eDUqaolT3bviOk9BB197+A8Vz/k7MC6ci2NE+yDDB7HAC8zU6LAx8Y
+  Iqvw7B/PSZ/pz4bUVFlTATif4mi1vO3lidRkdHRtM7UePSn2rUpOi0gtXBP3bLu5
+  YjHJN7wx5cugMEyroKITG5gL0Nxtu21qtOlHX4Hc4KdE2JqzCPOsS4zsZGhgwhPs
+  fl3hbtVFTqbOlwL9vy1fudXcolIE/ZTcxQ+er07ZFZdKCXayR9PPs64heamfn0fp
+  TConQSX2BnZdhIEYW+cKzEC/bLc=
+  -----END CERTIFICATE-----
+date: 2015-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,6 +94,7 @@ files:
 - lib/toxiproxy/toxic_collection.rb
 - lib/toxiproxy/version.rb
 - shipit.rubygems.yml
+- test/fixtures/toxiproxy.json
 - test/test_helper.rb
 - test/toxiproxy_test.rb
 - toxiproxy.gemspec
@@ -99,6 +122,4 @@ 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
+test_files: []