vagrant-brightbox 0.1.0

data/lib/vagrant-brightbox/action/map_cloud_ip.rb

@@ -0,0 +1,68 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      class MapCloudIp
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::map_cloud_ips")
+        end
+
+        def call(env)
+
+          @app.call(env)
+
+	  machine = env[:machine]
+
+	  if no_cloud_ips_required?(env[:machine].config.vm.networks)
+	    @logger.info("No public ipv4 network required")
+	    return
+	  end
+
+	  if machine.id.nil?
+	    @logger.info("No server found - can't map public ips")
+	    return
+	  end
+
+	  server = env[:brightbox_compute].servers.get(machine.id)
+	  if server.nil?
+	    @logger.info("Machine cannot be found; assuming it got destroyed.")
+	    machine.id = nil
+	    return
+	  end
+
+	  unless server.cloud_ips.empty?
+	    @logger.info("Server already has public ip address.")
+	    return
+	  end
+
+	  target_ip = unallocated_cloud_ip(env[:brightbox_compute].cloud_ips)
+
+	  if target_ip.nil?
+	    @logger.info("Couldn't allocate a cloud ip")
+	    env[:ui].info I18n.t("vagrant_brightbox.errors.no_free_cloud_ip")
+	    return
+	  end
+
+	  target_ip.map(server)
+	  env[:ui].info I18n.t("vagrant_brightbox.mapped_cloud_ip", :server => server.id, :cloud_ip => target_ip.public_ip)
+
+        end
+
+	def unallocated_cloud_ip(ip_list)
+	  ip_list.all.detect(ip_list.method(:allocate)) {|ip| !ip.mapped? }
+	end
+
+	def no_cloud_ips_required?(networks)
+	  networks.any? do |x|
+	    x.first == :private_network ||
+	      (x.first == :public_network && element[1][:ipv6])
+	  end
+	end
+
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Brightbox
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_brightbox.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Brightbox
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_brightbox.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/read_ssh_info.rb

@@ -0,0 +1,69 @@
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:brightbox_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(brightbox, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = brightbox.servers.get(machine.id)
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          # Get the configuration
+          region = machine.provider_config.region
+          config = machine.provider_config.get_region_config(region)
+
+	  if use_private_network?(machine.config.vm.networks)
+	    host_name = server.fqdn
+	  elsif use_ipv6_public_network?(machine.config.vm.networks)
+	    host_name = "ipv6.#{server.fqdn}"
+	  elsif server.public_ip_address
+	    host_name = server.dns_name
+	  else
+	    @logger.error("Cannot find public ip address - defaulting to private")
+	    host_name = server.fqdn
+	  end
+
+          # Read the DNS info
+          return {
+            :host => host_name,
+            :port => 22,
+            :private_key_path => config.ssh_private_key_path,
+            :username => config.ssh_username
+          }
+        end
+
+	def use_private_network?(network_structure)
+	  network_structure.any? {|x| x.first == :private_network }
+	end
+
+	def use_ipv6_public_network?(network_structure)
+	  network_structure.any? do |element|
+	    element.first == :public_network && element[1][:ipv6]
+	  end
+	end
+
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/read_state.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:brightbox_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(brightbox, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = brightbox.servers.get(machine.id)
+          if server.nil? || [:deleted, :deleting, :failed].include?(server.state.to_sym)
+            # The machine can't be found
+            @logger.info("Machine not found or terminated, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.state.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/start_server.rb

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This starts the server via the api
+      class StartServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::start_server")
+        end
+
+        def call(env)
+          server = env[:brightbox_compute].servers.get(env[:machine].id)
+
+	  # Make the action idempotent
+	  unless server.ready?
+	    # start the server.
+	    env[:ui].info(I18n.t("vagrant_brightbox.starting_server"))
+	    server.start
+	  end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/sync_folders.rb

@@ -0,0 +1,58 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Brightbox server.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_brightbox::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            env[:ui].info(I18n.t("vagrant_brightbox.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-brightbox/util/timer"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [p.class.to_s, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-brightbox/action/unsupported.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Brightbox
+    module Action
+      class Unsupported
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+	  env[:ui].warn(I18n.t("vagrant_brightbox.unsupported"))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-brightbox/action.rb

@@ -0,0 +1,166 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Brightbox
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to destroy the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+	      b2.use ConnectBrightbox
+	      b2.use DeleteServer
+	    else
+              b2.use MessageNotCreated
+            end
+          end
+        end
+      end
+
+      # This action is called to halt the server - gracefully or by force.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+	  b.use ConfigValidate
+	  b.use Call, IsCreated do |env, b2|
+	    if env[:result]
+	      b2.use Call, GracefulHalt, :inactive, :active do |env2, b3|
+	        if !env2[:result]
+		  b3.use ConnectBrightbox
+		  b3.use ForcedHalt
+		end
+	      end
+	    else
+	      b2.use MessageNotCreated
+	    end
+	  end
+	end
+      end
+
+      # This action reloads the machine - essentially shutting it down
+      # and bringing it back up again in the new configuration.
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+	  b.use Call, IsCreated do |env, b2|
+	    if env[:result]
+	      b2.use action_halt
+	      b2.use action_up
+	    else
+	      b2.use MessageNotCreated
+	    end
+	  end
+	end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+	      b2.use Provision
+	      b2.use SyncFolders
+	    else
+              b2.use MessageNotCreated
+            end
+          end
+        end
+      end
+      
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectBrightbox
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectBrightbox
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+	      b2.use SSHExec
+	    else
+              b2.use MessageNotCreated
+            end
+          end
+        end
+      end
+
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+	  b.use ConnectBrightbox
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+	      b2.use Call, IsRunning do |env2, b3|
+	        if env2[:result]
+		  b3.use MessageAlreadyCreated
+		else
+		  b3.use StartServer
+		  b3.use MapCloudIp
+		end
+	      end
+	    else
+	      b2.use Provision
+	      b2.use SyncFolders
+	      b2.use CreateServer
+	      b2.use MapCloudIp
+            end
+          end
+        end
+      end
+
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+	  b.use Unsupported
+	end
+      end
+
+      class << self
+	alias action_resume action_package
+	alias action_suspend action_package
+      end
+        
+        
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectBrightbox, action_root.join("connect_brightbox")
+      autoload :CreateServer, action_root.join("create_server")
+      autoload :DeleteServer, action_root.join("delete_server")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsRunning, action_root.join("is_running")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :SyncFolders, action_root.join("sync_folders")
+      autoload :MapCloudIp, action_root.join("map_cloud_ip")
+      autoload :ForcedHalt, action_root.join("forced_halt")
+      autoload :StartServer, action_root.join("start_server")
+      autoload :Unsupported, action_root.join("unsupported")
+    end
+  end
+end