blimpy 0.3.8 → 0.4.0

data/Gemfile

@@ -10,4 +10,9 @@ group :development do
   gem 'aruba'
   gem 'tempdir'
   gem 'pry'
+  if RUBY_VERSION > '1.9'
+    gem 'ruby-debug19', :require => 'ruby-debug'
+  else
+    gem 'ruby-debug'
+  end
 end

data/Rakefile

@@ -16,7 +16,11 @@ namespace :cucumber do
   end
 
   Cucumber::Rake::Task.new('integration') do |t|
-    t.cucumber_opts = cucumber_opts + ' --tags @slow'
+    t.cucumber_opts = cucumber_opts + ' --tags @slow --tags ~@openstack'
+  end
+
+  Cucumber::Rake::Task.new('openstack') do |t|
+    t.cucumber_opts = cucumber_opts + ' --tags @openstack'
   end
 end
 

data/features/cli/start.feature

@@ -14,7 +14,6 @@ Feature: Start a VM or cluster of VMs in the cloud
       """
       Blimpy.fleet do |f|
         f.add(:aws) do |host|
-          host.group = 'Simple'
           host.name = 'Cucumber Host'
         end
       end
@@ -46,7 +45,6 @@ Feature: Start a VM or cluster of VMs in the cloud
       """
       Blimpy.fleet do |f|
         f.add(:aws) do |host|
-          host.group = 'Simple'
           host.name = 'Cucumber Host'
         end
       end
@@ -72,23 +70,3 @@ Feature: Start a VM or cluster of VMs in the cloud
     When I run `blimpy start`
     Then the exit status should be 0
 
-  @slow @destroy @openstack @wip
-  Scenario: start with an OpenStack Blimpfile
-    Given I have the Blimpfile:
-      """
-      Blimpy.fleet do |f|
-        f.add(:openstack) do |host|
-          host.name = 'Cucumber Host'
-        end
-      end
-      """
-    When I run `blimpy start`
-    Then the exit status should be 0
-    And the output should contain:
-      """
-      Up, up and away!
-      """
-    And the output should contain:
-      """
-      online at:
-      """

data/features/liveries.feature

@@ -0,0 +1,9 @@
+Feature: Craft machines based on a livery
+  In order to bootstrap a machine that looks how I expect it to
+  As a Blimpy user
+  When I specify a specific livery then that livery should provision
+  the host the way I would expect it to.
+
+
+  @slow @destroy @wip
+  Scenario: freebsd_puppet

data/features/openstack.feature

@@ -0,0 +1,26 @@
+Feature: Provision machines on an OpenStack cluster
+  In order to use a private cloud, powered by OpenStack
+  As a Blimpy user
+  I should be able to tspin up machines on OpenStack the same way I am able to
+  on AWS
+
+
+  @slow @destroy @openstack
+  Scenario: Start with a functional Blimpfile
+    Given I have the Blimpfile:
+      """
+      Blimpy.fleet do |f|
+        f.add(:openstack) do |host|
+          host.name = 'Cucumber Host'
+          host.image_id = '5e624061-65cc-4e67-b6c5-8e7ac6e38ea7' # Maps to our intenral 'lucid-server' image
+          host.region = 'test' # This is the "test" tenant
+          host.flavor = 'm1.tiny'
+        end
+      end
+      """
+    When I run `blimpy start`
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      online at:
+      """

data/features/step_definitions/cli_steps.rb

@@ -21,8 +21,8 @@ Given /^I have a single VM running$/ do
   @name = 'Cucumber host'
   @server_id = '0xdeadbeef'
   File.open(File.join(d, "#{@server_id}.blimp"), 'w') do |f|
-    f.write("name: #{@name}\n")
-    f.write("dns: foo.bar\n")
+    f.write(":name: #{@name}\n")
+    f.write(":dns: foo.bar\n")
   end
 end
 

data/lib/blimpy.rb

@@ -13,6 +13,8 @@ module Blimpy
     fleet
   end
 
+  class UnknownError < Exception
+  end
   class InvalidBlimpFileError < Exception
   end
   class InvalidRegionError < Exception
@@ -23,4 +25,6 @@ module Blimpy
   end
   class InvalidShipException < Exception
   end
+  class UnsupportedFeatureException < Exception
+  end
 end

data/lib/blimpy/box.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+require 'yaml'
 require 'blimpy/helpers/state'
 require 'blimpy/livery'
 require 'blimpy/keys'
@@ -10,13 +12,14 @@ module Blimpy
 
     attr_reader :allowed_regions, :region
     attr_accessor :image_id, :flavor, :group, :ports
+    attr_accessor :dns, :internal_dns
     attr_accessor :name, :tags, :fleet_id, :username, :livery
 
 
     def self.from_instance_id(an_id, data)
-      return if data['type'].nil?
+      return if data[:type].nil?
 
-      name = data['type'].upcase.to_sym
+      name = data[:type].to_sym
       return unless Blimpy::Boxes.const_defined? name
 
       klass = Blimpy::Boxes.const_get(name)
@@ -25,7 +28,7 @@ module Blimpy
       return if server.nil?
 
       box = klass.new(server)
-      box.name = data['name']
+      box.with_data(an_id, data)
       box
     end
 
@@ -49,22 +52,27 @@ module Blimpy
     end
 
     def online!
-      File.open(state_file, 'a') do |f|
-        f.write("dns: #{@server.dns_name}\n")
-        f.write("internal_dns: #{@server.private_dns_name}\n")
-      end
+      write_state_file
     end
 
     def validate!
       raise NotImplementedError, '#validate! should be defined in a subclass of Blimpy::Box'
     end
 
+    def prestart
+    end
+
     def start
       ensure_state_folder
+      prestart
       @server = create_host
+      poststart
       write_state_file
     end
 
+    def poststart
+    end
+
     def bootstrap
       @exec_commands = false
       unless livery.nil?
@@ -85,20 +93,42 @@ module Blimpy
       end
     end
 
+    def predestroy
+    end
+
     def destroy
       unless @server.nil?
+        predestroy
         @server.destroy
+        postdestroy
         File.unlink(state_file)
       end
     end
 
+    def postdestroy
+    end
+
+    def type
+      # We only really care about the class name as part of the Blimpy::Boxes
+      # module
+      self.class.to_s.split('::').last
+    end
+
+    def serializable_attributes
+      [:type, :name, :region, :dns, :internal_dns]
+    end
+
+    def immutable_attributes
+      [:type]
+    end
+
     def write_state_file
+      data = {}
+      serializable_attributes.each do |attr|
+        data[attr] = self.send(attr)
+      end
       File.open(state_file, 'w') do |f|
-        # We only really care about the class name as part of the Blimpy::Boxes
-        # module
-        f.write("type: #{self.class.to_s.split('::').last}\n")
-        f.write("name: #{@name}\n")
-        f.write("region: #{@region}\n")
+        f.write(data.to_yaml)
       end
     end
 
@@ -122,11 +152,13 @@ module Blimpy
 
 
     def with_data(ship_id, data)
-      @dns = data['dns']
-      @region = data['region']
+      data.each do |key, value|
+        next if immutable_attributes.include? key.to_sym
+        self.send("#{key}=", value)
+      end
     end
 
-    def dns_name
+    def dns
       @dns ||= begin
           if @server.nil?
             'no name'
@@ -136,9 +168,14 @@ module Blimpy
         end
     end
 
-    def internal_dns_name
-      return @server.private_dns_name unless @server.nil?
-      'no name'
+    def internal_dns
+      @internal_dns ||= begin
+                          if @server.nil?
+                            'no name'
+                          else
+                            @server.private_dns_name
+                          end
+                        end
     end
 
     def run_command(*args)
@@ -156,13 +193,13 @@ module Blimpy
         args = ARGV[2 .. -1]
       end
       run_command('ssh', '-o', 'StrictHostKeyChecking=no',
-                  '-l', username, dns_name, *args)
+                  '-l', username, dns, *args)
     end
 
     def scp_file(filename, directory='')
       filename = File.expand_path(filename)
       run_command('scp', '-o', 'StrictHostKeyChecking=no',
-                  filename, "#{username}@#{dns_name}:#{directory}", *ARGV[3..-1])
+                  filename, "#{username}@#{dns}:#{directory}", *ARGV[3..-1])
     end
 
     def bootstrap_livery
@@ -187,7 +224,7 @@ module Blimpy
                     '--exclude=.svn',
                     '--exclude=.blimpy.d',
                     '.',
-                    "#{username}@#{dns_name}:#{dir_name}/")
+                    "#{username}@#{dns}:#{dir_name}/")
       else
         puts "Remote host has no rsync(1), falling back to copying a full tarball over"
         tarball = Blimpy::Livery.tarball_directory(Dir.pwd)

data/lib/blimpy/boxes/aws.rb

@@ -42,10 +42,18 @@ module Blimpy::Boxes
 
     private
 
+    def import_key
+      material = Blimpy::Keys.public_key
+      begin
+        fog.import_key_pair(Blimpy::Keys.key_name, material)
+      rescue Fog::Compute::AWS::Error => e
+      end
+    end
+
     def create_host
       tags = @tags.merge({:Name => @name, :CreatedBy => 'Blimpy', :BlimpyFleetId => @fleet_id})
 
-      Blimpy::Keys.import_key(fog)
+      import_key
       generated_group = Blimpy::SecurityGroups.ensure_group(fog, @ports + [22])
       groups = [@group, generated_group].compact
       fog.servers.create(:image_id => @image_id,

data/lib/blimpy/boxes/openstack.rb

@@ -4,9 +4,155 @@ require 'blimpy/boxes'
 module Blimpy::Boxes
   class OpenStack < Blimpy::Box
     def self.fog_server_for_instance(id, blimpdata)
-      region = blimpdata['region']
-      fog = Fog::Compute.new(:provider => 'OpenStack', :region => region)
+      region = blimpdata[:region]
+      fog = Fog::Compute.new(:provider => 'OpenStack', :openstack_tenant => region)
       fog.servers.get(id)
     end
+
+    class FloatingIp
+      attr_accessor :address, :id
+
+      def initialize(address, id)
+        @address = address
+        @id = id
+      end
+
+      def to_yaml(*args)
+        {:address => address, :id => id}.to_yaml
+      end
+    end
+
+    attr_accessor :key_name, :floating_ip
+
+    def initialize(server=nil)
+      super(server)
+      @username = 'ubuntu'
+      @flavor = 'm1.tiny'
+      @group = 'default'
+      @key_name = nil
+      @floating_ip = nil
+    end
+
+    def ports=(new_pors)
+      raise Blimpy::UnsupportedFeatureException, 'Opening arbitrary ports in OpenStack is currently not supported'
+    end
+
+    def wait_for_state(until_state, &block)
+      until @server.ready?
+        sleep 1
+        @server.reload
+      end
+      # OpenStack doesn't seem to like it if you try to associate the IP
+      # address too early, but will properly associate it after the machine is
+      # ready
+      associate_ip
+    end
+
+    def serializable_attributes
+      super + [:floating_ip]
+    end
+
+    def dns
+      if floating_ip.nil?
+        'unavailable'
+      else
+        floating_ip.address
+      end
+    end
+
+    def internal_dns
+      'unavailable'
+    end
+
+    def validate!
+      if @region.nil?
+        raise Blimpy::BoxValidationError, "Cannot spin up machine without a set region"
+      end
+
+      if flavor_id(@flavor).nil?
+        raise Blimpy::BoxValidationError, "'#{@flavor}' is not a valid OpenStack tenant name"
+      end
+    end
+
+    def fog
+      @fog ||= begin
+        Fog::Compute.new(:provider => 'openstack', :openstack_tenant => @region)
+      end
+    end
+
+    def flavors
+      @flavors ||= fog.flavors
+    end
+
+    def flavor_id(name)
+      flavors.each do |flavor|
+        return flavor.id if flavor.name == name
+      end
+      nil
+    end
+
+    def prestart
+      allocate_ip
+    end
+
+    def allocate_ip
+      response = fog.allocate_address
+      unless response.status == 200
+        raise Blimpy::UnknownError, "Blimpy was unable to allocate a floating IP address; #{response.inspect}"
+      end
+
+      details = response.body['floating_ip']
+      @floating_ip = FloatingIp.new(details['ip'], details['id'])
+    end
+
+    def associate_ip
+      if floating_ip.nil?
+        raise Blimpy::UnknownError, "Blimpy cannot associate a floating IP until it's been allocated properly!"
+      end
+      response = fog.associate_address(@server.id, floating_ip.address)
+
+      unless response.status == 202
+        raise Blimpy::UnknownError, "Blimpy failed to associate the IP somehow #{response.inspect}"
+      end
+    end
+
+    def predestroy
+      disassociate_ip unless floating_ip.nil?
+    end
+
+    def postdestroy
+      deallocate_ip unless floating_ip.nil?
+    end
+
+    def disassociate_ip
+      fog.disassociate_address(@server.id, floating_ip.address)
+    end
+
+    def deallocate_ip
+      fog.release_address(floating_ip.id)
+    end
+
+    private
+
+    def import_key
+      material = Blimpy::Keys.public_key
+      begin
+        fog.create_key_pair(Blimpy::Keys.key_name, material)
+      rescue Excon::Errors::Conflict => e
+      end
+    end
+
+    def create_host
+      tags = @tags.merge({:Name => @name, :CreatedBy => 'Blimpy', :BlimpyFleetId => @fleet_id})
+
+      groups = [@group]
+      import_key
+      fog.servers.create(:image_ref => image_id,
+                         :flavor_ref => flavor_id(@flavor),
+                         :key_name => Blimpy::Keys.key_name,
+                         :groups => groups,
+                         :name => @name,
+                         :tags => tags)
+    end
   end
 end

data/lib/blimpy/cli.rb

@@ -28,7 +28,7 @@ module Blimpy
         ship_id = nil
         data = nil
         engine.fleet.members.each do |instance_id, instance_data|
-          next unless instance_data['name'] == name
+          next unless instance_data[:name] == name
           ship_id = instance_id
           data = instance_data
           break
@@ -88,7 +88,7 @@ module Blimpy
       blimps.each do |blimp, data|
         instance_id = File.basename(blimp)
         instance_id = instance_id.split('.blimp').first
-        puts "#{data['name']} (#{instance_id}) is: online at #{data['dns']}"
+        puts "#{data[:name]} (#{instance_id}) is: online at #{data[:dns]}"
       end
     end
 

data/lib/blimpy/engine.rb

@@ -1,6 +1,7 @@
 
 require 'rubygems'
-require 'fog'
+require 'fog/core'
+require 'fog/compute'
 
 module Blimpy
   class Engine

data/lib/blimpy/fleet.rb

@@ -1,5 +1,6 @@
 require 'blimpy/helpers/state'
 require 'blimpy/boxes/aws'
+require 'blimpy/boxes/openstack'
 
 module Blimpy
   class Fleet
@@ -14,7 +15,7 @@ module Blimpy
     end
 
     def valid_types
-      [:aws]
+      [:aws, :openstack]
     end
 
     def add(box_type, &block)
@@ -25,7 +26,13 @@ module Blimpy
         return false
       end
 
-      box = Blimpy::Boxes::AWS.new
+      box = nil
+      if box_type == :aws
+        box = Blimpy::Boxes::AWS.new
+      end
+      if box_type == :openstack
+        box = Blimpy::Boxes::OpenStack.new
+      end
 
       if box.nil?
         return false
@@ -115,7 +122,7 @@ module Blimpy
         host.wait_for_state('running') {  }
         @airborn = true
         print "\n"
-        puts ">> #{host.name} online at: #{host.dns_name}"
+        puts ">> #{host.name} online at: #{host.dns}"
         host.online!
         host.bootstrap
         puts

data/lib/blimpy/keys.rb

@@ -1,9 +1,8 @@
-require 'fog'
 require 'socket'
 
 module Blimpy
   module Keys
-    def self.import_key(fog)
+    def self.public_key
       filename = File.expand_path('~/.ssh/id_rsa.pub')
       unless File.exists? filename
         filename = File.expand_path('~/.ssh/id_dsa.pub')
@@ -12,15 +11,11 @@ module Blimpy
         end
       end
 
-      material = File.open(filename, 'r').read
-      begin
-        fog.import_key_pair(key_name, material)
-      rescue Fog::Compute::AWS::Error => e
-      end
+      File.open(filename, 'r').read
     end
 
     def self.key_name
-      "Blimpy-#{ENV['USER']}@#{Socket.gethostname}"
+      "Blimpy-#{ENV['USER']}-#{Socket.gethostname}"
     end
   end
 end

data/lib/blimpy/version.rb

@@ -1,3 +1,3 @@
 module Blimpy
-  VERSION = "0.3.8"
+  VERSION = "0.4.0"
 end

data/spec/blimpy/box_spec.rb

@@ -61,7 +61,7 @@ describe Blimpy::Box do
       end
 
       it 'should set the dns_name' do
-        subject.dns_name.should == data['dns']
+        subject.dns.should == data['dns']
       end
 
       it 'should set the region' do
@@ -75,6 +75,8 @@ describe Blimpy::Box do
     let(:server) do
       server = double('Fog::Compute::AWS::Server')
       server.stub(:id).and_return(server_id)
+      server.stub(:dns_name).and_return('test')
+      server.stub(:private_dns_name).and_return('test')
       server
     end
 
@@ -126,7 +128,7 @@ describe Blimpy::Box do
       end
 
       it 'should fail if the "type" is not a defined Box class' do
-        result = Blimpy::Box.from_instance_id('someid', {'type' => 'MAGIC'})
+        result = Blimpy::Box.from_instance_id('someid', {:type => 'MAGIC'})
         result.should be_nil
       end
 
@@ -137,7 +139,7 @@ describe Blimpy::Box do
         end
 
         it 'should create a new AWS Box instance' do
-          result = Blimpy::Box.from_instance_id('someid', {'type' => 'AWS'})
+          result = Blimpy::Box.from_instance_id('someid', {:type => 'AWS'})
           result.should be_instance_of Blimpy::Boxes::AWS
         end
       end

data/spec/blimpy/boxes/openstack_spec.rb

@@ -1,6 +1,18 @@
 require 'spec_helper'
 require 'blimpy/boxes/openstack'
 
+shared_context 'valid floating_ip' do
+  let(:floating) do
+    floating = double('FloatingIp')
+    floating.stub(:address).and_return('127.0.0.1')
+    floating.stub(:id).and_return(7)
+    floating
+  end
+  before :each do
+    subject.stub(:floating_ip).and_return(floating)
+  end
+end
+
 describe Blimpy::Boxes::OpenStack do
   describe '#image_id' do
     it 'should be nil by default' do
@@ -8,6 +20,24 @@ describe Blimpy::Boxes::OpenStack do
     end
   end
 
+  describe '#username' do
+    it 'should be "ubuntu" by default' do
+      subject.username.should == 'ubuntu'
+    end
+  end
+
+  describe '#flavor' do
+    it 'should be "m1.tiny" by default' do
+      subject.flavor.should == 'm1.tiny'
+    end
+  end
+
+  describe '#group' do
+    it 'should be "default" by default' do
+      subject.group.should == 'default'
+    end
+  end
+
   describe '#allowed_regions' do
     it 'should be nil by default' do
       subject.allowed_regions.should be_nil
@@ -21,4 +51,257 @@ describe Blimpy::Boxes::OpenStack do
       subject.region.should == :elbonia
     end
   end
+
+  describe '#ports=' do
+    it 'should be disabled currently' do
+      expect {
+        subject.ports = [22, 8080]
+      }.to raise_error(Blimpy::UnsupportedFeatureException)
+    end
+  end
+
+  describe '#validate!' do
+    it 'should raise a validation error if there isn\'t a region' do
+      subject.region = nil
+      expect {
+        subject.validate!
+      }.to raise_error(Blimpy::BoxValidationError)
+    end
+  end
+
+  context 'with mocked flavors' do
+    let(:fog) { double('Fog') }
+    let(:flavors) do
+      flavor = double('Fog::Compute::OpenStack::Flavor')
+      flavor.stub(:id).and_return('1')
+      flavor.stub(:name).and_return('m1.tiny')
+      [flavor]
+    end
+
+    before :each do
+      fog.should_receive(:flavors).and_return(flavors)
+      subject.should_receive(:fog).and_return(fog)
+    end
+
+    describe '#flavors' do
+      it 'should pull the list of flavors from Fog' do
+        subject.flavors.should == flavors
+      end
+    end
+
+    describe '#flavor_id' do
+      it 'should filter out the right flavor' do
+        subject.flavor_id('m1.tiny').should == '1'
+      end
+
+      it 'should return nil if the flavor doesn\'t exist' do
+        subject.flavor_id('invalid').should be_nil
+      end
+    end
+
+    describe '#validate!' do
+      it 'should raise a validation error with an invalid flavor' do
+        subject.flavor = 'invalid'
+        subject.region = 'test'
+        expect {
+          subject.validate!
+        }.to raise_error(Blimpy::BoxValidationError)
+      end
+
+    end
+
+  end
+
+  describe '#prestart' do
+    it 'should allocate an IP' do
+      subject.should_receive(:allocate_ip)
+      subject.prestart
+    end
+  end
+
+  describe '#allocate_ip' do
+    let(:fog) { double('Fog') }
+
+    before :each do
+      subject.stub(:fog).and_return(fog)
+    end
+
+    context 'with a bad response' do
+      let(:response) do
+        response = double('Excon::Response')
+        response.stub(:status).and_return(500)
+        response
+      end
+
+      it 'should raise an error if we cannot allocate the IP' do
+        fog.should_receive(:allocate_address).and_return(response)
+        expect {
+          subject.allocate_ip
+        }.to raise_error(Blimpy::UnknownError)
+      end
+    end
+
+    context 'with a good response' do
+      let(:response) do
+        response = double('Excon::Response')
+        response.stub(:status).and_return(200)
+        response.stub(:body).and_return({"floating_ip"=>
+            {"instance_id"=>nil,
+            "ip"=>"10.38.12.109",
+            "fixed_ip"=>nil,
+            "id"=>109,
+            "pool"=>"nova"}})
+        response
+      end
+
+      it 'should allocate and store the floating IP info' do
+        fog.should_receive(:allocate_address).and_return(response)
+
+        subject.allocate_ip
+        subject.floating_ip.address.should == '10.38.12.109'
+        subject.floating_ip.id.should == 109
+      end
+    end
+  end
+
+  describe '#associate_ip' do
+    let(:fog) { double('Fog') }
+    include_context 'valid floating_ip'
+    let(:server) do
+      server = double('Fog::Compute::Server')
+      server.stub(:id).and_return(server_id)
+      server
+    end
+    let(:server_id) { 'fake-id' }
+
+    subject { described_class.new(server) }
+
+    before :each do
+      subject.stub(:fog).and_return(fog)
+    end
+
+    it 'should raise an exception if a floating IP hasn\'t been created' do
+      subject.stub(:floating_ip).and_return(nil)
+      expect {
+        subject.associate_ip
+      }.to raise_error(Blimpy::UnknownError)
+    end
+
+    context 'with a good response' do
+      let(:response) do
+        response = double('Excon::Response')
+        response.stub(:status).and_return(202)
+        response
+      end
+
+      it 'should associate the right IP to the right instance ID' do
+        fog.should_receive(:associate_address).with(server_id, floating.address).and_return(response)
+        subject.associate_ip
+      end
+    end
+
+    context 'with a bad response' do
+      let(:response) do
+        response = double('Excon::Response')
+        response.stub(:status).and_return(500)
+        response
+      end
+
+      it 'should raise an error' do
+        subject.stub(:floating_ip).and_return(floating)
+        fog.should_receive(:associate_address).with(server_id, floating.address).and_return(response)
+        expect {
+          subject.associate_ip
+        }.to raise_error(Blimpy::UnknownError)
+      end
+    end
+  end
+
+  describe '#predestroy' do
+    context 'if the server has a floating IP' do
+      include_context 'valid floating_ip'
+
+      it 'should disasscoaite it' do
+        subject.should_receive(:disassociate_ip)
+        subject.predestroy
+      end
+    end
+
+    context 'if the server has no floating IP' do
+      it 'should not try to disassociate it' do
+        subject.should_receive(:disassociate_ip).never
+        subject.predestroy
+      end
+    end
+  end
+
+  describe '#postdestroy' do
+    context 'if the server has a floating IP' do
+      include_context 'valid floating_ip'
+
+      it 'should deallocate the IP' do
+        subject.should_receive(:deallocate_ip)
+        subject.postdestroy
+      end
+    end
+
+    context 'if the server has no floating IP' do
+      it 'should not try to deallocate the IP' do
+        subject.should_receive(:deallocate_ip).never
+        subject.postdestroy
+      end
+    end
+  end
+
+  describe '#disassociate_ip' do
+    let(:fog) { double('Fog') }
+    include_context 'valid floating_ip'
+    let(:server) do
+      server = double('Fog::Compute::Server')
+      server.stub(:id).and_return(server_id)
+      server
+    end
+    let(:server_id) { 'fake-id' }
+
+    subject { described_class.new(server) }
+
+    before :each do
+      subject.stub(:fog).and_return(fog)
+    end
+
+    it 'should disassociate the right IP to the right instance ID' do
+      fog.should_receive(:disassociate_address).with(server_id, floating.address)
+      subject.disassociate_ip
+    end
+  end
+
+  describe '#deallocate_ip' do
+    let(:fog) { double('Fog') }
+    include_context 'valid floating_ip'
+
+    before :each do
+      subject.stub(:fog).and_return(fog)
+    end
+
+    context 'with a good response' do
+      let(:response) do
+        response = double('Excon::Response')
+        response.stub(:status).and_return(202)
+        response
+      end
+
+      it 'should release the right IP by floating_ip ID' do
+        fog.should_receive(:release_address).with(floating.id).and_return(response)
+        subject.deallocate_ip
+      end
+    end
+  end
+end
+
+describe Blimpy::Boxes::OpenStack::FloatingIp do
+  subject do
+    described_class.new('127.0.0.1', 1)
+  end
+
+  it { should respond_to(:to_yaml) }
 end

data/spec/blimpy/keys_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 require 'blimpy/keys'
 
 describe Blimpy::Keys do
-  describe '#import_key' do
+  describe '#public_key' do
     context 'with no SSH keys' do
       it 'should raise a SSHKeyNotFoundError' do
         File.stub(:exists?).and_return(false)
         expect {
-          subject.import_key(nil)
+          subject.public_key
         }.to raise_error(Blimpy::SSHKeyNotFoundError)
       end
     end
@@ -21,7 +21,7 @@ describe Blimpy::Keys do
     it do
       hostname = 'rspec'
       Socket.should_receive(:gethostname).and_return(hostname)
-      subject.key_name.should == "Blimpy-tester@#{hostname}"
+      subject.key_name.should == "Blimpy-tester-#{hostname}"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blimpy
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-09 00:00:00.000000000Z
+date: 2012-07-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
-  requirement: &13551560 !ruby/object:Gem::Requirement
+  requirement: &23292620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13551560
+  version_requirements: *23292620
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &13550720 !ruby/object:Gem::Requirement
+  requirement: &23292160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13550720
+  version_requirements: *23292160
 - !ruby/object:Gem::Dependency
   name: minitar
-  requirement: &13549340 !ruby/object:Gem::Requirement
+  requirement: &23291720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *13549340
+  version_requirements: *23291720
 description: Blimpy is a tool for managing a fleet of machines in the CLOUD!
 email:
 - tyler@monkeypox.org
@@ -65,6 +65,8 @@ files:
 - features/cli/ssh.feature
 - features/cli/start.feature
 - features/cli/status.feature
+- features/liveries.feature
+- features/openstack.feature
 - features/step_definitions/cli_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb
@@ -108,7 +110,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3611461695599472567
+      hash: -3073527661709686604
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -117,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3611461695599472567
+      hash: -3073527661709686604
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10
@@ -131,6 +133,8 @@ test_files:
 - features/cli/ssh.feature
 - features/cli/start.feature
 - features/cli/status.feature
+- features/liveries.feature
+- features/openstack.feature
 - features/step_definitions/cli_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb