vagrant-clusterfuck 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b20a1129ef6b8c782255ea00ddbf8026a45b50d0
+  data.tar.gz: 98d03daca3a5d97656db316f603535a6730777e0
+SHA512:
+  metadata.gz: cd9624b80c9795f879abca0774f57cd8182cbc740a466a90ec582f75357b4091c184aaa0e5c3b87081cbe0776ab54a1acab727054c403c4a5c774281c2c1b80f
+  data.tar.gz: 38e9a07958f3ed4e73e453f53e80ac8d4b3092d335e081b3151606cd863488b9d8df543828b923874eb43ca2bb3d8f026f7e78bba784dff56bd9c0c65864bee8

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/
+.vagrant/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in clusterfuck.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Simon Eskildsen
+
+MIT License
+
+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,6 @@
+# Clusterfuck
+
+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.
+
+## Usage

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end

data/Vagrantfile

@@ -0,0 +1,23 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+require_relative "lib/clusterfuck"
+require_relative "cluster"
+
+Vagrant.configure('2') do |config|
+  config.vm.box = "ubuntu/trusty64"
+
+  config.vm.provider "virtualbox" do |box|
+    box.memory = 256
+  end
+
+  cluster = Clusterfuck::Cluster[:test]
+  cluster[:spine].build(config)
+  cluster[:leaf1].build(config)
+
+  cluster[:host11].build(config) do |box|
+    box.vm.provision :shell, inline: "echo 1 > /tmp/test"
+  end
+
+  cluster[:leaf2].build(config)
+  cluster[:host21].build(config)
+end

data/cluster.rb

@@ -0,0 +1,13 @@
+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

data/clusterfuck.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clusterfuck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-clusterfuck"
+  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.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "byebug"
+end

data/lib/clusterfuck/bgp_peer.rb

@@ -0,0 +1,43 @@
+module Clusterfuck
+  class BGPPeer < Machine
+    attr_accessor :bgp_asn,
+      :bgp_router_id,
+      :bgp_announced
+
+    def initialize(name, **args)
+      super
+
+      @bgp_announced = args[:announced] ? Array(args[:announced]) : []
+      @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)
+      }
+    end
+
+    class ASNFactory
+      @asn = 64999
+
+      def self.next
+        @asn += 1
+      end
+    end
+
+    class RouterIDFactory
+      @id = IPAddr.new("10.0.20.1")
+
+      def self.next
+        @id = @id.succ
+      end
+    end
+  end
+end

data/lib/clusterfuck/cluster.rb

@@ -0,0 +1,74 @@
+module Clusterfuck
+  class Cluster
+    attr_reader :graph, :name
+
+    def initialize(name)
+      @name = name
+      @nodes = {}
+      @graph = {}
+    end
+
+    def self.create(name)
+      @clusters ||= {}
+      @clusters[name] = Cluster.new(name)
+    end
+
+    def self.[](name)
+      @clusters[name]
+    end
+
+    def self.all
+      @clusters.values
+    end
+
+    def nodes
+      @nodes.values
+    end
+
+    def [](name)
+      @nodes[name]
+    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
+
+      nodes.permutation(2).each do |(a, b)|
+        @graph[a] << b
+      end
+    end
+
+    def adjacent?(a, b)
+      adjacent(a).include?(b)
+    end
+
+    def adjacent(a)
+      @graph[a]
+    end
+
+    def register(node)
+      @nodes[node.name] = node unless @nodes[node.name]
+      @graph[node] = [] unless @graph[node]
+    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)
+        }
+      }
+    end
+
+    private
+    def in_subnet?(subnet, node)
+      node.subnets.any? { |ip| subnet.include?(ip) }
+    end
+  end
+end

data/lib/clusterfuck/core_ext/ipaddr.rb

@@ -0,0 +1,14 @@
+class IPAddr
+  def netmask
+    _to_string(@mask_addr)
+  end
+
+  def cidr
+    IPAddr.new(netmask).to_i.to_s(2).count("1")
+  end
+
+  def to_cidr
+    to_string + "/" + cidr.to_s
+  end
+end
+

data/lib/clusterfuck/leaf_spine_dsl.rb

@@ -0,0 +1,45 @@
+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/machine.rb

@@ -0,0 +1,78 @@
+module Clusterfuck
+  class Machine
+    attr_reader :name, :ssh_port, :routes, :gateway
+    attr_accessor :subnets, :provisioners, :network
+
+    def initialize(name, **args)
+      @name = name
+      @subnets = []
+      @ssh_port = args[:ssh_port] || PortFactory.next
+      @gateway = args[:gateway]
+      @routes = args[:routes]
+    end
+
+    def overlapping_subnets(other)
+      network.overlapping_subnets(self, other)
+    end
+
+    def build(config)
+      config.vm.define(name) do |box|
+        box.vm.hostname = name
+
+        # Set up SSH on a predictable port which allows us to hook into it
+        # during tests.
+        box.vm.network :forwarded_port,
+          guest: 22,
+          host: ssh_port,
+          id: "ssh"
+
+        subnets.each do |subnet|
+          box.vm.network :private_network,
+            ip: subnet.to_s,
+            # TODO Troll Rubby people by using a refinement
+            netmask: subnet.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
+            # AWS/CI support.
+            virtualbox__intnet: true
+        end
+
+        if gateway
+          box.vm.provision :file,
+            source: tmp_routes_file,
+            destination: "/tmp/network-clusterfuck"
+
+          box.vm.provision :shell,
+            inline: <<-EOS
+mv /tmp/network-clusterfuck /etc/network/if-up.d/clusterfuck
+chmod +x /etc/network/if-up.d/clusterfuck
+ifdown eth1
+ifup eth1
+EOS
+        end
+
+        yield box if block_given?
+      end
+    end
+
+    private
+    # TODO clean this up
+    def tmp_routes_file
+      path = File.expand_path("../../../templates/routes.sh.erb", __FILE__)
+      result = ERB.new(File.read(path)).result(binding)
+      temp = Tempfile.new("routes")
+      ObjectSpace.undefine_finalizer(temp) # finalizer removes it, nthx
+      temp.write(result)
+      temp.path
+    end
+
+    class PortFactory
+      @port = 28344
+
+      def self.next
+        @port += 1
+      end
+    end
+  end
+end

data/lib/clusterfuck/quagga_bgp_router.rb

@@ -0,0 +1,65 @@
+module Clusterfuck
+  class QuaggaBGPRouter < BGPPeer
+    def build(config)
+      super(config)
+
+      config.vm.define(name) do |box|
+        box.vm.provision :shell, inline: <<-EOS
+  mkdir -p /tmp/quagga
+  chown -R vagrant /tmp/quagga
+
+  apt-get update
+  apt-get -y install quagga
+  EOS
+
+        # TODO should be configured from BGP module if enabled
+        # TODO have to move to /tmp/ first and then later to /etc/quagga because
+        # Vagrant doens't copy as root.
+        box.vm.provision :file,
+          source: tmp_daemons_config,
+          destination: "/tmp/quagga/daemons"
+
+        box.vm.provision :file,
+          source: tmp_zebra_config,
+          destination: "/tmp/quagga/zebra.conf"
+
+        box.vm.provision :file,
+          source: tmp_bgp_config,
+          destination: "/tmp/quagga/bgpd.conf"
+
+        box.vm.provision :shell, inline: <<-EOS
+  echo net.ipv4.ip_forward=1 > /etc/sysctl.d/60-clusterfuck.conf
+  sysctl -p /etc/sysctl.d/60-clusterfuck.conf
+
+  mv /tmp/quagga/* /etc/quagga
+  chown quagga.quagga /etc/quagga/*.conf
+  chmod 640 /etc/quagga/*.conf
+
+  service quagga restart
+EOS
+      end
+    end
+
+    private
+    # TODO clean up these messy functions
+    def tmp_zebra_config
+      File.expand_path("../../../templates/quagga.zebra.conf.erb", __FILE__)
+    end
+
+    def tmp_daemons_config
+      File.expand_path("../../../templates/quagga.daemons.erb", __FILE__)
+    end
+
+    def tmp_bgp_config
+      temp = Tempfile.new("routes")
+      ObjectSpace.undefine_finalizer(temp) # finalizer removes it, nthx
+      temp.write(bgp_config)
+      temp.path
+    end
+
+    def bgp_config
+      path = File.expand_path("../../../templates/quagga.bgpd.conf.erb", __FILE__)
+      ERB.new(File.read(path)).result(binding)
+    end
+  end
+end

data/lib/clusterfuck/subnet_factory.rb

@@ -0,0 +1,26 @@
+module Clusterfuck
+  class SubnetFactory
+    attr_reader :subnet
+
+    START_SUBNET = "10.0.39.0/24"
+    @previous = IPAddr.new(START_SUBNET)
+
+    def initialize(subnet)
+      @subnet = subnet
+    end
+
+    def next
+      @subnet = @subnet.succ
+    end
+
+    def self.next(cidr = 24)
+      # succ twice to start at x.x.x.2
+      @previous = @previous.mask(cidr).to_range.last.succ.succ
+      SubnetFactory.new(@previous)
+    end
+
+    def self.reset
+      @previous = IPAddr.new(START_SUBNET)
+    end
+  end
+end

data/lib/clusterfuck/test_helper.rb

@@ -0,0 +1,36 @@
+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/lib/clusterfuck/version.rb

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

data/lib/clusterfuck.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,43 @@
+! -*- bgp -*-
+!
+! BGPd configuration file
+!
+hostname leaf
+password zebra
+!enable password please-set-at-here
+!
+!bgp mulitple-instance
+!
+router bgp <%= bgp_asn %>
+ bgp router-id <%= bgp_router_id %>
+ timers bgp 1 3
+ <% bgp_announced.each do |subnet| %>
+ network <%= subnet.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
+ <% end %>
+ 
+ip community-list standard cm-prefmod-300 permit 65534:300
+ip community-list standard cm-prefmod-200 permit 65534:200
+ip community-list standard cm-prefmod-100 permit 65534:100
+
+route-map DOWNSTREAM permit 10
+ match community cm-prefmod-300
+ set local-preference 300
+route-map DOWNSTREAM permit 20
+ match community cm-prefmod-200
+ set local-preference 200
+route-map DOWNSTREAM permit 30
+ match community cm-prefmod-100
+ set local-preference 100
+route-map DOWNSTREAM permit 40
+ set local-preference 90
+
+log file /var/log/quagga/bgpd.log
+!
+log stdout

data/templates/quagga.daemons.erb

@@ -0,0 +1,31 @@
+# This file tells the quagga package which daemons to start.
+#
+# Entries are in the format: <daemon>=(yes|no|priority)
+#   0, "no"  = disabled
+#   1, "yes" = highest priority
+#   2 .. 10  = lower priorities
+# Read /usr/share/doc/quagga/README.Debian for details.
+#
+# Sample configurations for these daemons can be found in
+# /usr/share/doc/quagga/examples/.
+#
+# ATTENTION:
+#
+# When activation a daemon at the first time, a config file, even if it is
+# empty, has to be present *and* be owned by the user and group "quagga", else
+# the daemon will not be started by /etc/init.d/quagga. The permissions should
+# be u=rw,g=r,o=.
+# When using "vtysh" such a config file is also needed. It should be owned by
+# group "quaggavty" and set to ug=rw,o= though. Check /etc/pam.d/quagga, too.
+#
+# The watchquagga daemon is always started. Per default in monitoring-only but
+# that can be changed via /etc/quagga/debian.conf.
+#
+zebra=yes
+bgpd=yes
+ospfd=no
+ospf6d=no
+ripd=no
+ripngd=no
+isisd=no
+babeld=no

data/templates/quagga.zebra.conf.erb

@@ -0,0 +1,23 @@
+! -*- zebra -*-
+!
+! zebra configuration file
+!
+hostname leaf1
+password zebra
+enable password zebra
+!
+! Interface's description.
+!
+!interface lo
+! description test of desc.
+!
+!interface sit0
+! multicast
+
+!
+! Static default route sample.
+!
+!ip route 0.0.0.0/0 203.181.89.241
+!
+
+log file /var/log/quagga/zebra.log

data/templates/routes.sh.erb

@@ -0,0 +1,34 @@
+#!/bin/sh -e
+# Provision routes on Vagrant controled interfaces.
+#
+# 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
+# the order of the network definitions. The alternative to this is to run the ip
+# commands on every boot, which is arguably even worse.
+#
+# TODO found out `private_network` takes an `auto_config => false` which allows
+# doing the `/etc/networks/interfaces` entry ourselves.
+#
+# TODO Send a patch to Vagrant core allowing specifying arbritrary network
+# interface parameters to the definitions. An example syntax could be:
+#
+#   config.vm.network :private_network, ip: "...", netmask: "...",
+#     interface: { up: "ip route add .. via .." }
+#
+# `iptool` commands don't need to specify the interface when they're part of of
+# the network hooks in the interface.
+
+if [ "$MODE" != start ]; then
+  exit 0
+fi
+
+if [ "$IFACE" != eth1 ]; then
+  exit 0
+fi
+
+<% routes.each do |route| %>
+ip route add <%= route.to_cidr %> via <%= gateway.overlapping_subnets(self).first %> dev eth1 || true
+<% end %>
+
+exit 0

data/test/bgp_peer_test.rb

@@ -0,0 +1,45 @@
+require_relative "test_helper"
+
+class TestBGPPeer < Minitest::Unit::TestCase
+  include Clusterfuck
+
+  def setup
+    @peer = BGPPeer.new(:peer)
+    @peer2 = BGPPeer.new(:peer2)
+    @cluster = Cluster.new(:test)
+  end
+
+  def test_assigned_random_asn_in_private_range
+    assert_instance_of Fixnum, @peer.bgp_asn
+    assert 65000 <= @peer.bgp_asn
+  end
+
+  def test_assigned_random_ipv4_ip_as_router_id
+    assert_match(/\d+\.\d+\.\d+\.\d+/, @peer.bgp_router_id.to_s)
+  end
+
+  def test_assigned_successive_asns
+    assert_equal @peer.bgp_asn + 1, @peer2.bgp_asn
+  end
+
+  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/helper_test.rb

@@ -0,0 +1,19 @@
+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/machine_test.rb

@@ -0,0 +1,24 @@
+require_relative "test_helper"
+
+class TestMachine < Minitest::Unit::TestCase
+  include Clusterfuck
+
+  def setup
+    @machine = Machine.new(:test)
+  end
+
+  def test_get_name
+    assert_equal :test, @machine.name
+  end
+
+  def test_assign_ssh_port
+    assert_kind_of Fixnum, @machine.ssh_port
+  end
+
+  def test_assign_successive_ssh_ports
+    first = @machine.ssh_port
+    second = Machine.new(:test2)
+
+    assert_equal first + 1, second.ssh_port
+  end
+end

data/test/network_test.rb

@@ -0,0 +1,201 @@
+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

data/test/subnet_test.rb

@@ -0,0 +1,48 @@
+require "minitest/autorun"
+require "minitest/unit"
+require_relative "../lib/clusterfuck"
+
+class TestSubnet < Minitest::Unit::TestCase
+  include Clusterfuck
+
+  def setup
+    SubnetFactory.reset
+  end
+
+  def test_next_subnet
+    subnet = SubnetFactory.next
+    assert_equal IPAddr.new("10.0.40.2"), subnet.next
+  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
+  end
+
+  def test_next_subnet_twice
+    subnet = SubnetFactory.next
+    assert_equal IPAddr.new("10.0.40.2"), subnet.next
+
+    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
+  end
+
+  def test_mask_returns_classic_syntax_netmask
+    subnet = SubnetFactory.next
+    assert_equal "255.255.255.0", subnet.next.netmask
+  end
+
+  def test_cidr_on_subet
+    assert_equal 24, IPAddr.new("10.0.0.0/24").cidr
+  end
+
+  def test_to_cidr_on_subet
+    assert_equal "10.0.0.0/24", IPAddr.new("10.0.0.0/24").to_cidr
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require "minitest/autorun"
+require_relative "../lib/clusterfuck"

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-clusterfuck
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Eskildsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: Clusterfuck let's you fuck with clusters
+email:
+- sirup@sirupsen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Vagrantfile
+- cluster.rb
+- clusterfuck.gemspec
+- lib/clusterfuck.rb
+- 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/routes.sh.erb
+- test/bgp_peer_test.rb
+- test/helper_test.rb
+- test/machine_test.rb
+- test/network_test.rb
+- test/subnet_test.rb
+- test/test_helper.rb
+homepage: ''
+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: Clusterfuck let's you fuck with clusters
+test_files:
+- test/bgp_peer_test.rb
+- test/helper_test.rb
+- test/machine_test.rb
+- test/network_test.rb
+- test/subnet_test.rb
+- test/test_helper.rb