vagrant-clusterfuck 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b20a1129ef6b8c782255ea00ddbf8026a45b50d0
-  data.tar.gz: 98d03daca3a5d97656db316f603535a6730777e0
+  metadata.gz: a5e7cd97a8254d5f76623b8405587f7b98985713
+  data.tar.gz: 617d505a9df006f677d39c7019ad66fc701f4733
 SHA512:
-  metadata.gz: cd9624b80c9795f879abca0774f57cd8182cbc740a466a90ec582f75357b4091c184aaa0e5c3b87081cbe0776ab54a1acab727054c403c4a5c774281c2c1b80f
-  data.tar.gz: 38e9a07958f3ed4e73e453f53e80ac8d4b3092d335e081b3151606cd863488b9d8df543828b923874eb43ca2bb3d8f026f7e78bba784dff56bd9c0c65864bee8
+  metadata.gz: e3e23a8411a5442b73c75659a912fe8c9c758d8fefa634293913c9e283ad9a9822eadef1da232daad3ae4c2e5182239f7a14a08e4b36861e441ed7e3dd836779
+  data.tar.gz: e1e7df9a9205bd49e923608cf8609cb27f3195d9e1a4564a90ce7e0e711ed44d237c275906530a9bcfe6fe6c22f898109e513fa68730e6aca800a1a7a5309ace

data/.gitignore

@@ -14,3 +14,4 @@
 mkmf.log
 vendor/
 .vagrant/
+*.gem

data/README.md

@@ -3,4 +3,58 @@
 Clusterfuck is a library for setting up a networked cluster of servers to test
 failure conditions against. It's a library to fuck with clusters.
 
+Currently it ships with a DSL for EBGP leaf-spine architectures, but has a
+generic backend that allows configuring any topology.
+
+It's currently using Virtualbox for probably no good reason other than
+`network_lab`, which this works derives from, used it. VMWare will be
+investigated in the future.
+
 ## Usage
+
+Install the `vagrant-clusterfuck` Vagrant plugin:
+
+```bash
+$ vagrant plugin install vagrant-clusterfuck
+```
+
+Create a `cluster.rb` file to define your cluster (see below). This must be a separate file,
+because it needs to be loaded in your test environment which does not implement
+the Vagrant DSL.
+
+In your `Vagrantfile`, build your cluster:
+
+```ruby
+cluster = Clusterfuck::Cluster[:test]
+cluster[:host1].build(config) do |box|
+  box.vm.provision :shell, inline: "echo 1 > /tmp/test"
+end
+
+cluster[:host2].build(config)
+```
+
+For a complete example, see the `Vagrantfile` and `cluster.rb` in this
+repository.
+
+```bash
+$ vagrant up --provider virtualbox
+```
+
+When making changes to `cluster.rb` and `Vagrantfile` make sure to reload and
+reprovision the cluster:
+
+```bash
+$ vagrant reload --provision
+```
+
+## Building Clusters
+
+Defining a cluster consists of two steps:
+
+1. **Creating instances.** You must specify which VMs your topology requires.
+2. **Layer 2 network.** You must specify the relationships between the VMs, that
+   is, the layer 2 network of which nodes belong to the same subnets and can
+   thus directly communicate with each other.
+
+Please see `./cluster.rb` for an annotated example. In the future we may build
+DSLs on top of the low-level graph DSL.

data/Vagrantfile

@@ -10,7 +10,7 @@ Vagrant.configure('2') do |config|
     box.memory = 256
   end
 
-  cluster = Clusterfuck::Cluster[:test]
+  cluster = Clusterfuck::BGPCluster[:test]
   cluster[:spine].build(config)
   cluster[:leaf1].build(config)
 
@@ -20,4 +20,5 @@ Vagrant.configure('2') do |config|
 
   cluster[:leaf2].build(config)
   cluster[:host21].build(config)
+  cluster[:host22].build(config)
 end

data/cluster.rb

@@ -1,13 +1,43 @@
-include Clusterfuck::LeafSpineDSL
-
-cluster :test do
-  spine :spine do
-    leaf :leaf1 do
-      host :host11
-    end
-
-    leaf :leaf2 do
-      host :host21, driver: Clusterfuck::BGPPeer
-    end
-  end
-end
+require_relative "lib/clusterfuck"
+include Clusterfuck
+
+# Create a BGPCluster. The BGPCluster is just a cluster that knows how to
+# discover neighbouring BGP nodes.
+cluster = BGPCluster.create(:test)
+
+# The VIP subnet includes all the VIPs that any BGPPeer can take and announce.
+# All hosts, even if they're on the same subnet as the node that owns the IP,
+# will go through their gateway to route the IP.
+vip_subnet = IPAddr.new("192.168.99.0/24")
+
+# Spine becomes the catchall for 10.0.0.0/16 which is the subnet all the nodes
+# belong to (each subnet is a /24).
+priv_subnet = IPAddr.new("10.0.0.0/16")
+
+# The Spine announces the VIP and private subnet.
+spine = QuaggaBGPRouter.new(:spine, announce: [vip_subnet, priv_subnet])
+
+# Define the leaf, announcements come later
+leaf1_subnet = SubnetFactory.next_subnet
+leaf1 = QuaggaBGPRouter.new(:leaf1, announce: leaf1_subnet.last_ip)
+
+leaf2_subnet = SubnetFactory.next_subnet
+leaf2 = QuaggaBGPRouter.new(:leaf2, announce: leaf2_subnet.last_ip)
+
+# A normal host. All the Spine's BGP announcements (vip + priv) will go through
+# the gateway.
+host11 = Machine.new(:host11, routes: spine.bgp_announce, gateway: leaf1)
+
+# A BGPPeer is just a machine with BGP information so that its BGP neighbours
+# will automatically add it as a BGP peer. This is for a node to run e.g.
+# ExaBGP.
+host21 = BGPPeer.new(:host21, routes: spine.bgp_announce, gateway: leaf2)
+host22 = Machine.new(:host22, routes: spine.bgp_announce, gateway: leaf2)
+
+# The spines and leaves have their own subnets
+cluster.connect(spine, leaf1)
+cluster.connect(spine, leaf2)
+
+# The leaves create a subnet with all their hosts.
+cluster.connect(leaf1, host11, subnet: leaf1_subnet)
+cluster.connect(leaf2, host21, host22, subnet: leaf2_subnet)

data/clusterfuck.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Clusterfuck::VERSION
   spec.authors       = ["Simon Eskildsen"]
   spec.email         = ["sirup@sirupsen.com"]
-  spec.summary       = %q{Clusterfuck let's you fuck with clusters}
-  spec.description   = %q{Clusterfuck let's you fuck with clusters}
+  spec.summary       = %q{Clusterfuck lets you fuck with clusters}
+  spec.description   = %q{Clusterfuck lets you fuck with clusters}
   spec.homepage      = ""
   spec.license       = "MIT"
 

data/lib/clusterfuck/bgp_peer.rb

@@ -2,26 +2,18 @@ module Clusterfuck
   class BGPPeer < Machine
     attr_accessor :bgp_asn,
       :bgp_router_id,
-      :bgp_announced
+      :bgp_announce
 
     def initialize(name, **args)
       super
 
-      @bgp_announced = args[:announced] ? Array(args[:announced]) : []
+      @bgp_announce = args[:announce] ? Array(args[:announce]) : []
       @bgp_asn = args[:asn] || ASNFactory.next
       @bgp_router_id = args[:router_id] || RouterIDFactory.next
     end
 
-    def bgp_announced
-      @bgp_announced.map { |a|
-        a.kind_of?(SubnetFactory) ? a.subnet : a 
-      }
-    end
-
     def bgp_neighbors
-      network.adjacent(self).select { |neighbor|
-        neighbor.kind_of?(BGPPeer)
-      }
+      cluster.bgp_neighbors(self)
     end
 
     class ASNFactory
@@ -32,6 +24,8 @@ module Clusterfuck
       end
     end
 
+    # A router ID just an IP to identify the router on BGP. It does not have to
+    # be equal to the IP; just has to be an IP. We just pick start somewhere.
     class RouterIDFactory
       @id = IPAddr.new("10.0.20.1")
 

data/lib/clusterfuck/cluster.rb

@@ -1,74 +1,65 @@
 module Clusterfuck
   class Cluster
-    attr_reader :graph, :name
+    attr_reader :name, :network
 
     def initialize(name)
       @name = name
-      @nodes = {}
       @graph = {}
     end
 
     def self.create(name)
-      @clusters ||= {}
-      @clusters[name] = Cluster.new(name)
+      @@clusters ||= {}
+      @@clusters[name] = self.new(name)
     end
 
     def self.[](name)
-      @clusters[name]
+      @@clusters[name]
     end
 
     def self.all
-      @clusters.values
+      @@clusters.values
     end
 
-    def nodes
-      @nodes.values
+    def find_by_name(name)
+      nodes.find { |node| node.name == name }
     end
+    alias_method :[], :find_by_name
 
-    def [](name)
-      @nodes[name]
+    def nodes
+      @graph.keys
     end
 
-    def connect(subnet_factory, *nodes)
-      nodes.each do |node|
-        register(node)
-
-        unless in_subnet?(subnet_factory.subnet, node)
-          node.subnets << subnet_factory.next
-          node.network = self
-        end
-      end
-
+    def connect(*nodes, subnet: SubnetFactory.next_subnet)
+      # Create a complete graph (a graph where all nodes are connected to each
+      # other) between all the nodes, because that's what a subnet is.
       nodes.permutation(2).each do |(a, b)|
+        @graph[a] ||= []
         @graph[a] << b
       end
-    end
 
-    def adjacent?(a, b)
-      adjacent(a).include?(b)
-    end
-
-    def adjacent(a)
-      @graph[a]
-    end
+      nodes.each do |node|
+        node.ips << subnet.next_ip
+        node.cluster = self
+      end
 
-    def register(node)
-      @nodes[node.name] = node unless @nodes[node.name]
-      @graph[node] = [] unless @graph[node]
+      subnet.last_ip
     end
 
-    def overlapping_subnets(a, b)
-      a_subnets, b_subnets = Array(a.subnets), Array(b.subnets)
-      a_subnets.select { |a_subnet|
-        b_subnets.find { |b_subnet|
-          a_subnet.include?(b_subnet)
+    def ip_in_same_subnet(a, b)
+      a.ips.find { |a_ip|
+        b.ips.find { |b_ip|
+          a_ip.include?(b_ip)
         }
       }
     end
+    alias_method :neighbor?, :ip_in_same_subnet
+  end
 
-    private
-    def in_subnet?(subnet, node)
-      node.subnets.any? { |ip| subnet.include?(ip) }
+  class BGPCluster < Cluster
+    def bgp_neighbors(node)
+      @graph[node].select { |neighbor|
+        neighbor.is_a?(BGPPeer)
+      }
     end
   end
 end

data/lib/clusterfuck/core_ext/ipaddr.rb

@@ -10,5 +10,9 @@ class IPAddr
   def to_cidr
     to_string + "/" + cidr.to_s
   end
+
+  def addr
+    to_string
+  end
 end
 

data/lib/clusterfuck/machine.rb

@@ -1,18 +1,18 @@
 module Clusterfuck
   class Machine
-    attr_reader :name, :ssh_port, :routes, :gateway
-    attr_accessor :subnets, :provisioners, :network
+    attr_reader :name, :ssh_port
+    attr_accessor :ips, :gateway, :routes, :cluster
 
     def initialize(name, **args)
       @name = name
-      @subnets = []
+      @ips = []
       @ssh_port = args[:ssh_port] || PortFactory.next
       @gateway = args[:gateway]
       @routes = args[:routes]
     end
 
-    def overlapping_subnets(other)
-      network.overlapping_subnets(self, other)
+    def ip_in_same_subnet(other)
+      cluster.ip_in_same_subnet(self, other)
     end
 
     def build(config)
@@ -26,11 +26,11 @@ module Clusterfuck
           host: ssh_port,
           id: "ssh"
 
-        subnets.each do |subnet|
+        ips.each do |ip|
           box.vm.network :private_network,
-            ip: subnet.to_s,
+            ip: ip.addr,
             # TODO Troll Rubby people by using a refinement
-            netmask: subnet.netmask,
+            netmask: ip.netmask,
             # TODO Vagrant already provides an abstraction for declaring networks
             # so we should not need to duplicate this abstraction by creating
             # subclasses for each provider. This bullshit needs to be gone for

data/lib/clusterfuck/quagga_bgp_router.rb

@@ -43,11 +43,11 @@ EOS
     private
     # TODO clean up these messy functions
     def tmp_zebra_config
-      File.expand_path("../../../templates/quagga.zebra.conf.erb", __FILE__)
+      File.expand_path("../../../templates/quagga.zebra.conf", __FILE__)
     end
 
     def tmp_daemons_config
-      File.expand_path("../../../templates/quagga.daemons.erb", __FILE__)
+      File.expand_path("../../../templates/quagga.daemons", __FILE__)
     end
 
     def tmp_bgp_config

data/lib/clusterfuck/subnet_factory.rb

@@ -1,20 +1,21 @@
 module Clusterfuck
   class SubnetFactory
-    attr_reader :subnet
+    attr_reader :last_ip
 
     START_SUBNET = "10.0.39.0/24"
     @previous = IPAddr.new(START_SUBNET)
 
-    def initialize(subnet)
-      @subnet = subnet
+    def initialize(last_ip)
+      @last_ip = last_ip
     end
 
-    def next
-      @subnet = @subnet.succ
+    def next_ip
+      @last_ip = @last_ip.succ
     end
 
-    def self.next(cidr = 24)
-      # succ twice to start at x.x.x.2
+    def self.next_subnet(cidr = 24)
+      # `succ` twice to start at x.x.2.1, for example:
+      # 10.0.39.1 -> 10.0.40.1
       @previous = @previous.mask(cidr).to_range.last.succ.succ
       SubnetFactory.new(@previous)
     end

data/lib/clusterfuck/version.rb

@@ -1,3 +1,3 @@
 module Clusterfuck
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/clusterfuck.rb

@@ -1,13 +1,11 @@
 require "ipaddr"
 require "erb"
-require_relative "clusterfuck/test_helper"
 require_relative "clusterfuck/cluster"
 require_relative "clusterfuck/subnet_factory"
 require_relative "clusterfuck/machine"
 require_relative "clusterfuck/bgp_peer"
 require_relative "clusterfuck/quagga_bgp_router"
 require_relative "clusterfuck/core_ext/ipaddr"
-require_relative "clusterfuck/leaf_spine_dsl"
 
 module Clusterfuck
 end

data/templates/quagga.bgpd.conf.erb

@@ -11,15 +11,15 @@ password zebra
 router bgp <%= bgp_asn %>
  bgp router-id <%= bgp_router_id %>
  timers bgp 1 3
- <% bgp_announced.each do |subnet| %>
- network <%= subnet.to_cidr %>
+ <% bgp_announce.each do |announce| %>
+ network <%= announce.to_cidr %>
  <% end %>
 
  <% bgp_neighbors.each do |node| %>
- neighbor <%= node.overlapping_subnets(self).first %> remote-as <%= node.bgp_asn %>
- neighbor <%= node.overlapping_subnets(self).first %> route-map DOWNSTREAM in
- neighbor <%= node.overlapping_subnets(self).first %> next-hop-self
- neighbor <%= node.overlapping_subnets(self).first %> advertisement-interval 1
+ neighbor <%= node.ip_in_same_subnet(self) %> remote-as <%= node.bgp_asn %>
+ neighbor <%= node.ip_in_same_subnet(self) %> route-map DOWNSTREAM in
+ neighbor <%= node.ip_in_same_subnet(self) %> next-hop-self
+ neighbor <%= node.ip_in_same_subnet(self) %> advertisement-interval 1
  <% end %>
  
 ip community-list standard cm-prefmod-300 permit 65534:300

data/templates/routes.sh.erb

@@ -3,7 +3,7 @@
 #
 # We can't do this in `/etc/networks/interfaces` because Vagrant doesn't support
 # adding arbritrary commands to its generated interfaces. This sucks, because it
-# means we have to hardcore the device names and the user has to guess them from
+# means we have to hardcode the device names and the user has to guess them from
 # the order of the network definitions. The alternative to this is to run the ip
 # commands on every boot, which is arguably even worse.
 #
@@ -28,7 +28,7 @@ if [ "$IFACE" != eth1 ]; then
 fi
 
 <% routes.each do |route| %>
-ip route add <%= route.to_cidr %> via <%= gateway.overlapping_subnets(self).first %> dev eth1 || true
+ip route add <%= route.to_cidr %> via <%= gateway.ip_in_same_subnet(self) %> dev eth1 || true
 <% end %>
 
 exit 0

data/test/bgp_network_test.rb

@@ -0,0 +1,51 @@
+require_relative "test_helper"
+
+class TestBGPCluster < Minitest::Unit::TestCase
+  include Clusterfuck
+
+  def setup
+    @cluster = BGPCluster.new(:test)
+  end
+
+  def test_bgp_neighbors_simple
+    one = BGPPeer.new(:peer1)
+    two = BGPPeer.new(:peer2)
+
+    @cluster.connect(one, two)
+
+    assert_equal [one], @cluster.bgp_neighbors(two)
+    assert_equal [two], @cluster.bgp_neighbors(one)
+  end
+
+  def test_bgp_neighbors_simple_tree
+    spine = BGPPeer.new(:spine)
+    leaf1 = BGPPeer.new(:leaf1)
+    leaf2 = BGPPeer.new(:leaf2)
+
+    @cluster.connect(spine, leaf1)
+    @cluster.connect(spine, leaf2)
+
+    assert_equal [leaf1, leaf2], @cluster.bgp_neighbors(spine)
+    assert_equal [spine], @cluster.bgp_neighbors(leaf1)
+    assert_equal [spine], @cluster.bgp_neighbors(leaf2)
+  end
+
+  def test_bgp_neighbors_tree_with_non_bgp_peers
+    spine = BGPPeer.new(:spine)
+    leaf1 = BGPPeer.new(:leaf1)
+    host11 = Machine.new(:host11)
+
+    leaf2 = BGPPeer.new(:leaf2)
+    host21 = Machine.new(:host21)
+
+    @cluster.connect(spine, leaf1)
+    @cluster.connect(spine, leaf2)
+
+    @cluster.connect(leaf1, host11)
+    @cluster.connect(leaf2, host21)
+
+    assert_equal [leaf1, leaf2], @cluster.bgp_neighbors(spine)
+    assert_equal [spine], @cluster.bgp_neighbors(leaf1)
+    assert_equal [spine], @cluster.bgp_neighbors(leaf2)
+  end
+end

data/test/bgp_peer_test.rb

@@ -25,21 +25,4 @@ class TestBGPPeer < Minitest::Unit::TestCase
   def test_assigned_different_default_ips_as_router_id
     refute_equal @peer.bgp_router_id, @peer2.bgp_router_id
   end
-
-  def test_bgp_neighbors_returns_direct_neighbours
-    @cluster.connect(SubnetFactory.next, @peer, @peer2)
-
-    assert_equal [@peer2], @peer.bgp_neighbors
-    assert_equal [@peer], @peer2.bgp_neighbors
-  end
-
-  def test_bgp_neighbours_doesnt_include_non_bgp_peers
-    @non_peer = Machine.new(:test)
-
-    @cluster.connect(SubnetFactory.next, @peer2, @peer)
-    @cluster.connect(SubnetFactory.next, @peer2, @non_peer)
-
-    assert_equal [@peer2], @peer.bgp_neighbors
-    assert_equal [@peer], @peer2.bgp_neighbors
-  end
 end

data/test/cluster_test.rb

@@ -0,0 +1,130 @@
+require "minitest/autorun"
+require "minitest/unit"
+require_relative "../lib/clusterfuck"
+
+class TestCluster < Minitest::Unit::TestCase
+  include Clusterfuck
+
+  def setup
+    SubnetFactory.reset
+    @cluster = Cluster.new(:test)
+  end
+
+  def test_two_machine_cluster
+    one = Machine.new(:one)
+    two = Machine.new(:two)
+
+    @cluster.connect(one, two)
+
+    assert_neighbor one, two
+  end
+
+  def test_simple_tree
+    root = Machine.new(:root)
+    leaf1 = Machine.new(:leaf1)
+    leaf2 = Machine.new(:leaf2)
+
+    @cluster.connect(root, leaf1)
+    @cluster.connect(root, leaf2)
+
+    assert_neighbor root, leaf1
+    assert_neighbor root, leaf2
+    refute_neighbor leaf1, leaf2
+  end
+
+  def test_different_ips_on_subnet
+    root = Machine.new(:root)
+    leaf1 = Machine.new(:leaf1)
+    leaf2 = Machine.new(:leaf2)
+
+    @cluster.connect(root, leaf1)
+    @cluster.connect(root, leaf2)
+
+    root_ips = root.ips.map(&:to_s)
+    refute root_ips.include?(*leaf1.ips), "Did not expect leaf1 and root to share ips"
+    refute root_ips.include?(*leaf2.ips), "Did not expect leaf2 and root to share ips"
+  end
+
+  def test_adjacent_on_simple_tree
+    root = Machine.new(:root)
+    leaf1 = Machine.new(:leaf1)
+    leaf2 = Machine.new(:leaf2)
+
+    @cluster.connect(root, leaf1)
+    @cluster.connect(root, leaf2)
+
+    assert_neighbor root, leaf1
+    assert_neighbor leaf1, root
+
+    assert_neighbor root, leaf2
+    assert_neighbor leaf2, root
+
+    refute_neighbor leaf1, leaf2
+    refute_neighbor leaf2, leaf1
+  end
+
+  def test_apply_subnetwork_to_larger_tree
+    root = Machine.new(:root)
+
+    leaf1 = Machine.new(:leaf1)
+    host11 = Machine.new(:host11)
+
+    leaf2 = Machine.new(:leaf2)
+    host21 = Machine.new(:host21)
+    host22 = Machine.new(:host22)
+
+    @cluster.connect(root, leaf1)
+    @cluster.connect(root, leaf2)
+    @cluster.connect(leaf2, host21, host22)
+    @cluster.connect(leaf1, host11)
+
+    assert_neighbor root, leaf1
+    assert_neighbor root, leaf2
+
+    refute_neighbor leaf1, leaf2
+    refute_neighbor leaf1, host21
+    refute_neighbor leaf1, host22
+
+    assert_neighbor leaf2, host21
+    assert_neighbor leaf2, host22
+    assert_neighbor host21, host22
+
+    assert_neighbor leaf1, host11
+  end
+
+  def test_node_is_assigned_ip_with_netmask
+    one = Machine.new(:one)
+    two = Machine.new(:two)
+
+    @cluster.connect(one, two)
+
+    assert_neighbor one, two
+
+    one_ip = one.ips.first
+    two_ip = two.ips.first
+
+    assert_equal "255.255.255.0", one_ip.netmask
+    assert_equal "10.0.40.2", one_ip.addr
+
+    assert_equal "255.255.255.0", two_ip.netmask
+    assert_equal "10.0.40.3", two_ip.addr
+  end
+
+  def test_ip_in_same_subnet_returns_shared_ip
+    one = Machine.new(:one)
+    two = Machine.new(:two)
+
+    @cluster.connect(one, two)
+
+    assert_equal "10.0.40.2/24", @cluster.ip_in_same_subnet(one, two).to_cidr
+  end
+
+  private
+  def assert_neighbor(*nodes)
+    assert @cluster.neighbor?(*nodes), "Expected #{nodes.inspect} to be neighbors"
+  end
+
+  def refute_neighbor(*nodes)
+    refute @cluster.neighbor?(*nodes), "Did not expect #{nodes.inspect} to be neighbors"
+  end
+end

data/test/machine_test.rb

@@ -5,6 +5,7 @@ class TestMachine < Minitest::Unit::TestCase
 
   def setup
     @machine = Machine.new(:test)
+    @cluster = Cluster.new(:test)
   end
 
   def test_get_name

data/test/subnet_test.rb

@@ -7,35 +7,27 @@ class TestSubnet < Minitest::Unit::TestCase
 
   def setup
     SubnetFactory.reset
+    @subnet = SubnetFactory.next_subnet
   end
 
   def test_next_subnet
-    subnet = SubnetFactory.next
-    assert_equal IPAddr.new("10.0.40.2"), subnet.next
+    assert_equal IPAddr.new("10.0.40.2"), @subnet.next_ip
   end
 
   def test_next_ip_on_subnet
-    subnet = SubnetFactory.next
-    assert_equal IPAddr.new("10.0.40.2"), subnet.next
-    assert_equal IPAddr.new("10.0.40.3"), subnet.next
+    assert_equal IPAddr.new("10.0.40.2"), @subnet.next_ip
+    assert_equal IPAddr.new("10.0.40.3"), @subnet.next_ip
   end
 
   def test_next_subnet_twice
-    subnet = SubnetFactory.next
-    assert_equal IPAddr.new("10.0.40.2"), subnet.next
+    assert_equal IPAddr.new("10.0.40.2"), @subnet.next_ip
 
-    subnet = SubnetFactory.next
-    assert_equal IPAddr.new("10.0.41.2"), subnet.next
-  end
-
-  def test_next_16_subnet
-    subnet = SubnetFactory.next(16)
-    assert_equal IPAddr.new("10.1.0.2"), subnet.next
+    subnet = SubnetFactory.next_subnet
+    assert_equal IPAddr.new("10.0.41.2"), subnet.next_ip
   end
 
   def test_mask_returns_classic_syntax_netmask
-    subnet = SubnetFactory.next
-    assert_equal "255.255.255.0", subnet.next.netmask
+    assert_equal "255.255.255.0", @subnet.next_ip.netmask
   end
 
   def test_cidr_on_subet

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-clusterfuck
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Simon Eskildsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-31 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Clusterfuck let's you fuck with clusters
+description: Clusterfuck lets you fuck with clusters
 email:
 - sirup@sirupsen.com
 executables: []
@@ -71,20 +71,18 @@ files:
 - lib/clusterfuck/bgp_peer.rb
 - lib/clusterfuck/cluster.rb
 - lib/clusterfuck/core_ext/ipaddr.rb
-- lib/clusterfuck/leaf_spine_dsl.rb
 - lib/clusterfuck/machine.rb
 - lib/clusterfuck/quagga_bgp_router.rb
 - lib/clusterfuck/subnet_factory.rb
-- lib/clusterfuck/test_helper.rb
 - lib/clusterfuck/version.rb
 - templates/quagga.bgpd.conf.erb
-- templates/quagga.daemons.erb
-- templates/quagga.zebra.conf.erb
+- templates/quagga.daemons
+- templates/quagga.zebra.conf
 - templates/routes.sh.erb
+- test/bgp_network_test.rb
 - test/bgp_peer_test.rb
-- test/helper_test.rb
+- test/cluster_test.rb
 - test/machine_test.rb
-- test/network_test.rb
 - test/subnet_test.rb
 - test/test_helper.rb
 homepage: ''
@@ -110,11 +108,11 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Clusterfuck let's you fuck with clusters
+summary: Clusterfuck lets you fuck with clusters
 test_files:
+- test/bgp_network_test.rb
 - test/bgp_peer_test.rb
-- test/helper_test.rb
+- test/cluster_test.rb
 - test/machine_test.rb
-- test/network_test.rb
 - test/subnet_test.rb
 - test/test_helper.rb

data/lib/clusterfuck/leaf_spine_dsl.rb

@@ -1,45 +0,0 @@
-module Clusterfuck
-  module LeafSpineDSL
-    def cluster(name, &block)
-      @cluster = Cluster.create(name)
-      yield(@cluster)
-    end
-
-    def spine(name, **args, &block)
-      vip_subnet = args[:vip_subnet] || IPAddr.new("192.168.99.1/24")
-      priv_subnet = args[:priv_subnet] || IPAddr.new("10.0.0.0/16")
-      args = { announced: [vip_subnet, priv_subnet] }.merge(args)
-
-      driver = args[:driver] || QuaggaBGPRouter
-
-      @spine = driver.new(name, args)
-      yield(@spine)
-    end
-
-    def leaf(name, **args, &block)
-      driver = args[:driver] || QuaggaBGPRouter
-      leaf_spine_subnet = args[:spine_subnet] || SubnetFactory.next
-
-      @leaf = driver.new(name, **args)
-      @cluster.connect(leaf_spine_subnet, @leaf, @spine)
-
-      yield(@leaf)
-    end
-
-    def host(name, **args)
-      driver = args[:driver] || Machine
-      leaf_subnet = args[:leaf_subnet] || SubnetFactory.next
-
-      args = {
-        gateway: @leaf,
-        routes:  @spine.bgp_announced,
-      }.merge(args)
-
-      machine = driver.new(name, args)
-
-      # TODO this sucks
-      @leaf.bgp_announced = @leaf.bgp_announced.push(leaf_subnet.subnet)
-      @cluster.connect(leaf_subnet, @leaf, machine)
-    end
-  end
-end

data/lib/clusterfuck/test_helper.rb

@@ -1,36 +0,0 @@
-module Clusterfuck
-  module TestHelper
-    SSHCommandFailedError = Class.new(StandardError)
-
-    def self.included(base)
-      require "./cluster"
-    end
-
-    # We do not check exit status, don't want to control people.
-    def ssh_command(host, command, cluster: nil)
-      `ssh -i .vagrant/machines/#{host}/virtualbox/private_key vagrant@127.0.0.1 -p #{host(host, cluster: cluster).ssh_port} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o IdentitiesOnly=yes -o LogLevel=fatal "#{command}"`
-    end
-
-    def host(name, cluster: nil)
-      cluster(cluster).nodes.find { |node| node.name == name }
-    end
-
-    def ip_to_host(ip, cluster: nil)
-      cluster(cluster).nodes.find { |host|
-        host.subnets.find { |subnet|
-          subnet == ip
-        }
-      }
-    end
-
-    # TODO add iptables(1) and nc(1) wrappers to cause ~chaos~
-    private
-    def cluster(name)
-      if name
-        Clusterfuck::Cluster[name]
-      else
-        Clusterfuck::Cluster.all.first
-      end
-    end
-  end
-end

data/test/helper_test.rb

@@ -1,19 +0,0 @@
-require_relative "test_helper"
-
-class TestTestHelper < Minitest::Unit::TestCase
-  include Clusterfuck::TestHelper
-
-  def test_host
-    assert_equal :leaf1, host(:leaf1).name
-  end
-
-  def test_ssh_command_into_node
-    output = ssh_command :leaf1, "hostname"
-    assert_equal "leaf1\n", output
-  end
-
-  def test_ip_to_host
-    spine_ip = host(:spine).subnets.first.to_s
-    assert_equal :spine, ip_to_host(spine_ip).name
-  end
-end

data/test/network_test.rb

@@ -1,201 +0,0 @@
-require "minitest/autorun"
-require "minitest/unit"
-require_relative "../lib/clusterfuck"
-
-class TestNetwork < Minitest::Unit::TestCase
-  include Clusterfuck
-
-  def setup
-    SubnetFactory.reset
-    @cluster = Cluster.new(:test)
-  end
-
-  def test_one_machine_cluster
-    one = Machine.new(:one)
-    @cluster.register(one)
-
-    assert_equal({one => []}, @cluster.graph)
-  end
-
-  def test_two_machine_cluster
-    one = Machine.new(:one)
-    two = Machine.new(:two)
-
-    @cluster.connect(SubnetFactory.next, one, two)
-
-    assert_equal({one => [two], two => [one]}, @cluster.graph)
-  end
-
-  def test_simple_tree
-    root = Machine.new(:root)
-    leaf1 = Machine.new(:leaf1)
-    leaf2 = Machine.new(:leaf2)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    assert_equal({root => [leaf1, leaf2], leaf1 => [root], leaf2 => [root]}, @cluster.graph)
-  end
-
-  def test_different_ips_on_subnet
-    root = Machine.new(:root)
-    leaf1 = Machine.new(:leaf1)
-    leaf2 = Machine.new(:leaf2)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    refute root.subnets.map(&:to_s).include?(leaf1.subnets.first.to_s)
-    refute root.subnets.map(&:to_s).include?(leaf2.subnets.first.to_s)
-  end
-
-  def test_adjacent_on_simple_tree
-    root = Machine.new(:root)
-    leaf1 = Machine.new(:leaf1)
-    leaf2 = Machine.new(:leaf2)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    assert @cluster.adjacent?(root, leaf1)
-    assert @cluster.adjacent?(leaf1, root)
-
-    assert @cluster.adjacent?(root, leaf2)
-    assert @cluster.adjacent?(leaf2, root)
-
-    refute @cluster.adjacent?(leaf1, leaf2)
-    refute @cluster.adjacent?(leaf2, leaf1)
-  end
-
-  def test_apply_subnetwork_to_connected_graph
-    one = Machine.new(:one)
-    two = Machine.new(:two)
-
-    @cluster.connect(SubnetFactory.next, one, two)
-
-    assert_equal [IPAddr.new("10.0.40.2")], one.subnets
-    assert_equal [IPAddr.new("10.0.40.3")], two.subnets
-
-    assert_overlapping_subnets one, two
-
-    assert_equal 1, one.subnets.size
-    assert_equal 1, two.subnets.size
-  end
-
-  def test_apply_subnetwork_to_simple_tree
-    root = Machine.new(:root)
-    leaf1 = Machine.new(:leaf1)
-    leaf2 = Machine.new(:leaf2)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    assert_overlapping_subnets root, leaf1
-    assert_overlapping_subnets root, leaf2
-    refute_overlapping_subnets leaf1, leaf2
-
-    assert_equal 2, root.subnets.size
-    assert_equal 1, leaf1.subnets.size
-    assert_equal 1, leaf2.subnets.size
-  end
-
-  def test_apply_subnetwork_to_larger_tree
-    root = Machine.new(:root)
-
-    leaf1 = Machine.new(:leaf1)
-    host11 = Machine.new(:host11)
-
-    leaf2 = Machine.new(:leaf2)
-    host21 = Machine.new(:host21)
-    host22 = Machine.new(:host21)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    leaf2_subnet = SubnetFactory.next
-    @cluster.connect(leaf2_subnet, leaf2, host21)
-    @cluster.connect(leaf2_subnet, leaf2, host22)
-    @cluster.connect(leaf2_subnet, host21, host22)
-
-    leaf1_subnet = SubnetFactory.next
-    @cluster.connect(leaf1_subnet, leaf1, host11)
-
-    assert_overlapping_subnets root, leaf1
-    assert_overlapping_subnets root, leaf2
-
-    refute_overlapping_subnets leaf1, leaf2
-    refute_overlapping_subnets leaf1, host21
-    refute_overlapping_subnets leaf1, host22
-
-    assert_overlapping_subnets leaf2, host21
-    assert_overlapping_subnets leaf2, host22
-    assert_overlapping_subnets host21, host22
-
-    assert_overlapping_subnets leaf1, host11
-
-    assert_equal 2, root.subnets.size
-
-    assert_equal 2, leaf2.subnets.size
-    assert_equal 1, host21.subnets.size
-    assert_equal 1, host22.subnets.size
-
-    assert_equal 2, leaf1.subnets.size
-    assert_equal 1, host11.subnets.size
-  end
-
-  def test_overlapping_subnets_with_one
-    one = Machine.new(:one)
-    two = Machine.new(:two)
-
-    @cluster.connect(SubnetFactory.next, one, two)
-
-    assert_equal [IPAddr.new("10.0.40.2")], @cluster.overlapping_subnets(one, two)
-  end
-
-  def test_overlapping_subnets_in_tree
-    root = Machine.new(:root)
-    leaf1 = Machine.new(:leaf1)
-    leaf2 = Machine.new(:leaf2)
-
-    @cluster.connect(SubnetFactory.next, root, leaf1)
-    @cluster.connect(SubnetFactory.next, root, leaf2)
-
-    assert_equal [IPAddr.new("10.0.40.2")], @cluster.overlapping_subnets(root, leaf1)
-    assert_equal [IPAddr.new("10.0.41.2")], @cluster.overlapping_subnets(root, leaf2)
-    assert_equal [], @cluster.overlapping_subnets(leaf1, leaf2)
-  end
-
-  def test_support_multiple_arguments_to_connect
-    one = Machine.new(:one)
-    two = Machine.new(:two)
-    three = Machine.new(:three)
-
-    @cluster.connect(SubnetFactory.next, one, two, three)
-
-    assert_overlapping_subnets one, two
-    assert_overlapping_subnets one, three
-    assert_overlapping_subnets two, three
-  end
-
-  private
-
-  def assert_overlapping_subnets(a, b)
-    assert overlapping_subnets?(a, b), <<-EOE
-Expected networks to overlap:
-  #{a.name}: #{a.subnets}
-  #{b.name}: #{b.subnets}
-EOE
-  end
-
-  def refute_overlapping_subnets(a, b)
-    refute overlapping_subnets?(a, b), <<-EOE
-Expected networks to not overlap:
-  #{a.name}: #{a.subnets}
-  #{b.name}: #{b.subnets}
-EOE
-  end
-
-  def overlapping_subnets?(a, b)
-    @cluster.overlapping_subnets(a, b).any?
-  end
-end