bosh-bootstrap 0.6.0 → 0.7.0

data/spec/spec_helper.rb

@@ -9,9 +9,14 @@ Bundler.setup(:default, :test)
 $:.unshift(File.expand_path("../../lib", __FILE__))
 
 require "rspec/core"
+require "bosh/providers"
 require "bosh-bootstrap"
 require "bosh-bootstrap/cli"
 
+# for the #sh helper
+require "rake"
+require "rake/file_utils"
+
 def spec_asset(filename)
   File.expand_path("../assets/#{filename}", __FILE__)
 end
@@ -22,9 +27,22 @@ def files_match(filename, expected_filename)
   file.should == expected_file
 end
 
+def setup_home_dir
+  home_dir = File.expand_path("../../tmp/home", __FILE__)
+  FileUtils.mkdir_p(home_dir)
+  ENV['HOME'] = home_dir
+
+  private_key = File.join(home_dir, ".ssh", "id_rsa")
+  unless File.exists?(private_key)
+    puts "Creating private keypair for inception VM specs..."
+    mkdir_p(File.dirname(private_key))
+    sh "ssh-keygen -f #{home_dir}/.ssh/id_rsa -N ''"
+  end
+end
+
 RSpec.configure do |c|
   c.before(:each) do
-    
+    setup_home_dir
   end
 
   c.color_enabled = true

data/spec/unit/aws_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+require "active_support/core_ext/hash/keys"
+
+describe "AWS deployment" do
+  include FileUtils
+  include Bosh::Bootstrap::Helpers::SettingsSetter
+
+  before do
+    Fog.mock!
+    Fog::Mock.reset
+    ENV['MANIFEST'] = File.expand_path("../../../tmp/test-manifest.yml", __FILE__)
+    rm_rf(ENV['MANIFEST'])
+    @cmd = Bosh::Bootstrap::Cli.new
+    @fog_credentials = {
+      :provider                 => 'AWS',
+      :aws_secret_access_key    => 'XXX',
+      :aws_access_key_id        => 'YYY'
+    }
+
+    setting "bosh_provider", "aws"
+    setting "region_code", "us-west-2"
+    setting "bosh_name", "test-bosh"
+    setting "inception.create_new", true
+    setting "bosh_username", "testuser"
+    setting "bosh_password", "testpass"
+    setting "bosh.password", "testpass"
+    setting "fog_credentials", @fog_credentials.stringify_keys
+    setting "bosh.salted_password", "pepper"
+    setting "bosh.persistent_disk", 16384
+  end
+
+  # used by +SettingsSetter+ to access the settings
+  def settings
+    @cmd.settings
+  end
+
+  def fog
+    @fog ||= connection = Fog::Compute.new(@fog_credentials.merge(:region => "us-west-2"))
+  end
+
+  def expected_manifest_content(filename, public_ip, subnet_id = nil)
+    file = File.read(filename)
+    file.gsub!('$MICROBOSH_IP$', public_ip)
+    file.gsub!('$SUBNET_ID$', subnet_id) if subnet_id
+    YAML.load(file)
+  end
+
+  it "creates a VPC inception/microbosh with the associated resources" do
+    # create a VPC
+    # create a BOSH subnet 10.10.0.0/24
+    # create BOSH security group
+    # create INCEPTION security group allowing only 22
+    # create NATS security group, allowing only 4222
+    # create DHCP options with 2 nameserver (1 amazon for public resolves, 1 for private resolves (.bosh)?)
+    # create Internet Gateway, attach to VPC
+    # create default route (0.0.0.0/0) to IG
+
+    # create inception VM (attaching elastic IP, sg of [BOSH, INCEPTION]) in BOSH subnet at 10.10.0.5
+    # create MB VM from inception VM (sg of [BOSH, NATS])  in BOSH subnet at 10.10.0.6
+
+    setting "use_vpc", true # TODO include in cli.rb
+
+    @cmd.should_receive(:provision_and_mount_volume)
+    @cmd.stub(:run_server).and_return(true)
+    @cmd.stub(:sleep)
+    @cmd.should_receive(:deploy_stage_6_setup_new_bosh)
+    @cmd.deploy
+
+    fog.addresses.should have(1).item # assigned to inception VM
+    inception_ip_address = fog.addresses.first
+
+    fog.vpcs.should have(1).item
+    vpc = fog.vpcs.first
+    vpc.cidr_block.should == "10.0.0.0/16"
+
+    fog.servers.should have(1).item
+    inception = fog.servers.first
+    inception_ip_address.domain.should == "vpc"
+
+    # TODO - fix fog so we can test public_ip_address
+    # inception.public_ip_address.should == inception_ip_address.public_ip
+
+    # TODO - fix fog so we can test private_ip_address
+    # inception.private_ip_address.should == "10.0.0.5"
+
+    fog.security_groups.should have(2).item
+
+    fog.internet_gateways.should have(1).item
+    ig = fog.internet_gateways.first
+
+    fog.subnets.should have(1).item
+    subnet = fog.subnets.first
+    subnet.vpc_id.should == vpc.id
+    subnet.cidr_block.should == "10.0.0.0/24"
+
+    # fog.route_tables.should have(1).item
+    # a IG that is assigned to the VPN
+    # a subnet (contains the inception VM; is included in micro_bosh_yml)
+
+    # TODO - fix fog so we can test private_ip_address
+    # settings["inception"]["ip_address"].should == "10.0.0.5"
+
+    inception_server = fog.servers.first
+    inception_server.dns_name.should == settings["inception"]["host"]
+
+    public_ip = settings["bosh"]["ip_address"]
+    public_ip.should == "10.0.0.6"
+
+    manifest_path = spec_asset("micro_bosh_yml/micro_bosh.aws_ec2.yml")
+    YAML.load(@cmd.micro_bosh_yml).should == expected_manifest_content(manifest_path, public_ip, subnet.subnet_id)
+  end
+
+  it "creates an EC2 inception/microbosh with the associated resources" do
+    setting "use_vpc", false
+
+    @cmd.should_receive(:provision_and_mount_volume)
+    @cmd.stub(:run_server).and_return(true)
+    @cmd.stub(:sleep)
+    @cmd.should_receive(:deploy_stage_6_setup_new_bosh)
+    @cmd.deploy
+
+    fog.addresses.should have(2).item
+    inception_ip_address = fog.addresses.first
+    inception_ip_address.domain.should == "standard"
+
+    fog.vpcs.should have(0).item
+    fog.servers.should have(1).item
+    fog.security_groups.should have(2).item
+
+    inception_server = fog.servers.first
+    inception_server.dns_name.should == settings["inception"]["host"]
+    public_ip = settings["bosh"]["ip_address"]
+    manifest_path = spec_asset("micro_bosh_yml/micro_bosh.aws_ec2.yml")
+    YAML.load(@cmd.micro_bosh_yml).should == expected_manifest_content(manifest_path, public_ip)
+  end
+end

data/spec/unit/bosh/providers/aws_spec.rb

@@ -0,0 +1,160 @@
+# Copyright (c) 2012-2013 Stark & Wayne, LLC
+
+require File.expand_path("../../../../spec_helper", __FILE__)
+
+# Specs for the aws provider
+describe Bosh::Providers do
+  include FileUtils
+
+  describe "AWS" do
+    before do
+      Fog.mock!
+      @fog_compute =  Fog::Compute.new(
+          :provider  => 'AWS', 
+          :aws_access_key_id  => 'MOCK_AWS_ACCESS_KEY_ID',
+          :aws_secret_access_key  => 'MOCK_AWS_SECRET_ACCESS_KEY')
+      @aws_provider = Bosh::Providers.for_bosh_provider_name("aws", @fog_compute)
+    end
+
+    describe "create security group" do
+      it "should open a single TCP port on a security group" do
+        ports = { ssh: 22 }
+        @aws_provider.create_security_group("sg1-name", "sg1-desc", ports)
+        created_sg = @fog_compute.security_groups.get("sg1-name")
+        created_sg.name.should == "sg1-name"
+        created_sg.description.should == "sg1-desc"
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>22, 
+            "toPort"=>22, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open a range of TCP ports" do
+        ports = { ssh: (22..30) }
+        @aws_provider.create_security_group("sg-range-name", "sg-range-desc", ports)
+        created_sg = @fog_compute.security_groups.get("sg-range-name")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>22, 
+            "toPort"=>30, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open a range of UDP ports" do
+        ports = { ssh: { protocol: "udp", ports: (60000..600050) } }
+        @aws_provider.create_security_group("sg-range-udp-name", "sg-range-udp-name", ports)
+        created_sg = @fog_compute.security_groups.get("sg-range-udp-name")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"udp",
+            "fromPort"=>60000, 
+            "toPort"=>600050, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open not open ports if they are already open" do
+        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
+        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60010..600040) } })
+        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
+        created_sg = @fog_compute.security_groups.get("sg2")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"udp",
+            "fromPort"=>60000, 
+            "toPort"=>600050, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open ports even if they are already open for a different protocol" do
+        @aws_provider.create_security_group("sg3", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
+        @aws_provider.create_security_group("sg3", "", { ssh: { protocol: "tcp", ports: (60000..600050) } })
+        created_sg = @fog_compute.security_groups.get("sg3")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"udp",
+            "fromPort"=>60000, 
+            "toPort"=>600050, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          },
+          { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>60000, 
+            "toPort"=>600050, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open ports even if they are already open for a different ip_range" do
+        default_ports = {
+           all_internal_tcp: { protocol: "tcp", ip_range: "1.1.1.1/32", ports: (0..65535) }
+        }
+        @aws_provider.create_security_group("sg6", "sg6", default_ports)
+        @aws_provider.create_security_group("sg6", "sg6", { mosh: { protocol: "tcp", ports: (15..30) } })
+        created_sg = @fog_compute.security_groups.get("sg6")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>0, 
+            "toPort"=>65535, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"1.1.1.1/32" } ] 
+          },
+          { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>15, 
+            "toPort"=>30, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+      it "should open ports on the default sg" do
+        @aws_provider.create_security_group("default", "default", { mosh: { protocol: "tcp", ports: (15..30) } })
+        created_sg = @fog_compute.security_groups.get("default")
+        expected_rule = { 
+            "ipProtocol"=>"tcp",
+            "fromPort"=>15, 
+            "toPort"=>30, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        created_sg.ip_permissions.should include expected_rule
+      end
+      #AWS allows overlapping port ranges, and it makes it easier to see the separate "rules" that were added
+      it "should create overlapping port ranges" do
+        @aws_provider.create_security_group("sg4", "", { ssh: { protocol: "udp", ports: (10..20) } })
+        @aws_provider.create_security_group("sg4", "", { ssh: { protocol: "udp", ports: (15..30) } })
+        created_sg = @fog_compute.security_groups.get("sg4")
+        created_sg.ip_permissions.should == [
+          { 
+            "ipProtocol"=>"udp",
+            "fromPort"=>10, 
+            "toPort"=>20, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          },
+          { 
+            "ipProtocol"=>"udp",
+            "fromPort"=>15, 
+            "toPort"=>30, 
+            "groups"=>[], 
+            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
+          }
+        ]
+      end
+    end
+  end
+end

data/spec/unit/cli_spec.rb

@@ -56,6 +56,8 @@ describe Bosh::Bootstrap do
 
     it "stage 4 - prepare inception VM" do
       testing_stage(4)
+      setting "git.name", "Dr Nic Williams"
+      setting "git.email", "drnicwilliams@gmail.com"
       setting "inception.username", "ubuntu"
       setting "bosh.password", "UNSALTED"
       @cmd.should_receive(:run_server).and_return(true)
@@ -107,9 +109,7 @@ describe Bosh::Bootstrap do
     # get the Name field, reverse sort, and return the first item
     it "should return the latest stable stemcell by default for AWS" do
       @cmd.settings["bosh_provider"] = "aws"
-      @cmd.should_receive(:`).
-        with("bosh public stemcells --tags micro,aws").
-        and_return(File.read(spec_asset("bosh/public_stemcells/aws_micro.out")))
+      @cmd.should_receive(:known_stable_micro_bosh_stemcell_version).and_return("0.8.1")
       @cmd.micro_bosh_stemcell_name.should == "micro-bosh-stemcell-aws-0.8.1.tgz"
     end
   end

data/spec/unit/cli_ssh_spec.rb

@@ -5,6 +5,7 @@ require File.expand_path("../../spec_helper", __FILE__)
 # Specs for 'ssh' related behavior. Includes CLI commands:
 # * ssh
 # * tmux
+# * mosh
 describe Bosh::Bootstrap do
   include FileUtils
 
@@ -43,5 +44,46 @@ describe Bosh::Bootstrap do
         @cmd.tmux
       end
     end
+
+    describe "mosh" do
+      before do
+        @cmd.settings['bosh_provider'] = 'aws'
+        Fog.mock!
+        fog_compute = Fog::Compute.new(
+          :provider  => 'AWS', 
+          :aws_access_key_id  => 'MOCK_AWS_ACCESS_KEY_ID',
+          :aws_secret_access_key  => 'MOCK_AWS_SECRET_ACCESS_KEY')
+        @cmd.stub!(:provider).and_return(Bosh::Providers.for_bosh_provider_name('aws', fog_compute))
+        @cmd.stub!(:fog_compute).and_return(fog_compute)
+        @cmd.fog_compute.stub!(:servers).and_return(double(:get => double(:groups => ['default'])))
+      end
+      after do
+        Fog.unmock!
+      end
+      it "should check whether mosh is installed" do
+         @cmd.should_receive(:system).
+          with("mosh --version")
+        @cmd.stub!(:exit)
+        @cmd.ensure_mosh_installed
+      end
+      it "launches mosh session" do
+        @cmd.stub!(:ensure_mosh_installed).and_return(true)
+        @cmd.should_receive(:exit)
+        @cmd.should_receive(:system).
+          with("mosh vcap@5.5.5.5")
+        @cmd.mosh
+      end
+      it "should ensure that the mosh ports are opened" do
+        expected_ports = {
+          mosh: { 
+            protocol: "udp", 
+            ports: (60000..60050) 
+          }
+        } 
+        @cmd.provider.stub!(:create_security_group)
+          .with('default','not used', expected_ports)
+        @cmd.ensure_security_group_allows_mosh
+      end
+    end
   end
 end

data/spec/unit/cli_upgrade_inception_spec.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2012-2013 Stark & Wayne, LLC
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+# Specs for 'upgrade' command
+describe Bosh::Bootstrap do
+  include FileUtils
+  include Bosh::Bootstrap::Helpers::SettingsSetter
+
+  # used by +SettingsSetter+ to access the settings
+  def settings
+    @cmd.settings
+  end
+
+  before do
+    ENV['MANIFEST'] = File.expand_path("../../../tmp/test-manifest.yml", __FILE__)
+    rm_rf(ENV['MANIFEST'])
+    @cmd = Bosh::Bootstrap::Cli.new
+  end
+
+  it "runs 'upgrade' command on an existing inception VM" do
+    setting "inception.prepared", true
+    setting "inception.username", "ubuntu"
+    setting "git.name", "Dr Nic Williams"
+    setting "git.email", "drnicwilliams@gmail.com"
+    setting "bosh.password", "UNSALTED"
+    setting "bosh.salted_password", "SALTED"
+    @cmd.should_receive(:run_server).and_return(true)
+    @cmd.upgrade_inception
+  end
+end

data/spec/unit/settings_setter_spec.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2012-2013 Stark & Wayne, LLC
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Bosh::Bootstrap::Helpers::SettingsSetter do
+  include Bosh::Bootstrap::Helpers::SettingsSetter
+
+  attr_reader :settings
+  before do
+    @settings = {}
+  end
+
+  def save_settings!
+  end
+
+  it "with_setting 'a'" do
+    with_setting "a" do |setting|
+      setting['value'] = "abc"
+    end
+    settings["a"]["value"].should == "abc"
+  end
+
+  it "with_setting 'a.b.c'" do
+    with_setting "a.b.c" do |setting|
+      setting['value'] = "abc"
+    end
+    settings["a"]["b"]["c"]["value"].should == "abc"
+  end
+end