vagrant-openstack-cloud-provider 1.1.4

data/lib/vagrant-openstack-cloud-provider/action/connect_openstack.rb

@@ -0,0 +1,34 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action connects to OpenStack, verifies credentials work, and
+      # puts the OpenStack connection object into the `:openstack_compute` key
+      # in the environment.
+      class ConnectOpenStack
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::connect_openstack")
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+          @logger.info("Connecting to OpenStack Compute...")
+          env[:openstack_compute] = Fog::Compute.new({
+                        :provider => :openstack,
+                        :openstack_region => config.region,
+                        :openstack_username => config.username,
+                        :openstack_api_key => config.api_key,
+                        :openstack_auth_url => config.endpoint,
+                        :openstack_tenant => config.tenant
+                    })
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/create_server.rb

@@ -0,0 +1,185 @@
+require "fog"
+require "log4r"
+require "json"
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This creates the OpenStack server.
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::create_server")
+        end
+
+        def server_to_be_available?(server)
+          raise if server.state == 'ERROR'
+          server.state == 'ACTIVE'
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+
+          if !config.networks.nil? and config.networks.any?
+            @logger.info("Connecting to OpenStack Network...")
+            env[:openstack_network] = Fog::Network.new({
+                          :provider => :openstack,
+                          :openstack_region => config.region,
+                          :openstack_username => config.username,
+                          :openstack_api_key => config.api_key,
+                          :openstack_auth_url => config.endpoint,
+                          :openstack_tenant => config.tenant
+                      })
+          end
+
+          # Find the flavor
+          env[:ui].info(I18n.t("vagrant_openstack.finding_flavor"))
+          flavor = find_matching(env[:openstack_compute].flavors.all, config.flavor)
+          raise Errors::NoMatchingFlavor if !flavor
+
+          # Find the image
+          env[:ui].info(I18n.t("vagrant_openstack.finding_image"))
+          image = find_matching(env[:openstack_compute].images, config.image)
+          raise Errors::NoMatchingImage if !image
+
+          # Find the networks
+          effective_networks = []
+          if !config.networks.nil? and config.networks.any?
+            env[:ui].info(I18n.t("vagrant_openstack.finding_network"))
+            available_networks = env[:openstack_network].list_networks[:body]["networks"]
+
+            for network_name in config.networks
+              match = find_matching(available_networks, network_name)
+              unless match
+                raise Errors::NoMatchingNetwork,
+                      :network_name => network_name
+              end
+              effective_networks << match
+            end
+          end
+
+          # Figure out the name for the server
+          server_name = config.server_name || env[:machine].name
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_openstack.launching_server"))
+          env[:ui].info(" -- Flavor: #{flavor.name}")
+          env[:ui].info(" -- Image: #{image.name}")
+          if effective_networks.any?
+            env[:ui].info(' -- Network(s): ')
+            for net in effective_networks
+              env[:ui].info("      - #{net['name']}")
+            end
+          end
+          env[:ui].info(" -- Name: #{server_name}")
+
+          openstack_nics = []
+
+          for net in effective_networks
+            openstack_nics << {'net_id' => net['id']}
+          end
+
+          # Build the options for launching...
+          options = {
+            :flavor_ref         => flavor.id,
+            :image_ref          => image.id,
+            :name               => server_name,
+            :key_name           => config.keypair_name,
+            :user_data_encoded  => Base64.encode64(config.user_data),
+            :metadata           => config.metadata,
+            :os_scheduler_hints => config.scheduler_hints
+          }
+
+          if openstack_nics.any?
+            options[:nics] = openstack_nics
+          end
+
+          # Create the server
+          server = env[:openstack_compute].servers.create(options)
+
+          # Store the ID right away so we can track it
+          env[:machine].id = server.id
+
+          # Wait for the server to finish building
+          env[:ui].info("Instance UUID: #{env[:machine].id}")
+          env[:ui].info(I18n.t("vagrant_openstack.waiting_for_build"))
+          retryable(:on => Timeout::Error, :tries => 200) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # Wait for the server to be ready
+            begin
+              (1..120).each do |n|
+                env[:ui].clear_line
+                env[:ui].report_progress(n, 120, true)
+                server = env[:openstack_compute].servers.get(env[:machine].id)
+                break if self.server_to_be_available?(server)
+                sleep 1
+              end
+              server = env[:openstack_compute].servers.get(env[:machine].id)
+              raise unless self.server_to_be_available?(server)
+            rescue
+              raise Errors::CreateBadState, :state => server.state
+            end
+          end
+
+          env[:machine].data_dir.join("cached_metadata").open("w+") do |f|
+            f.write(server.to_json)
+          end
+
+          unless env[:interrupted]
+            # Clear the line one more time so the progress is removed
+            env[:ui].clear_line
+            ssh_is_responding?(env)
+            env[:ui].info(I18n.t("vagrant_openstack.ready"))
+          end
+
+          @app.call(env)
+        end
+        protected
+
+        def ssh_responding?(env)
+           begin
+             # Wait for SSH to become available
+             env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
+             (1..60).each do |n|
+               begin
+                 # If we're interrupted then just back out
+                 break if env[:interrupted]
+                 break if env[:machine].communicate.ready?
+               rescue Errno::ENETUNREACH
+               end
+               sleep 2
+             end
+             raise unless env[:machine].communicate.ready?
+           rescue
+             raise Errors::SshUnavailable
+           end
+        end
+
+        # This method finds a matching _thing_ in a collection of
+        # _things_. This works matching if the ID or NAME equals to
+        # `name`. Or, if `name` is a regexp, a partial match is chosen
+        # as well.
+        def find_matching(collection, name)
+          collection.each do |single|
+            if single.is_a?(Hash)
+              return single if single['name'] == name
+            else
+              return single if single.id == name
+              return single if single.name == name
+              return single if name.is_a?(Regexp) && name =~ single.name
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/delete_server.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This deletes the running server, if there is one.
+      class DeleteServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::delete_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.deleting_server"))
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            server.destroy
+            env[:machine].id = nil
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/is_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/message_already_created.rb

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

data/lib/vagrant-openstack-cloud-provider/action/message_not_created.rb

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

data/lib/vagrant-openstack-cloud-provider/action/read_ssh_info_from_api.rb

@@ -0,0 +1,46 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfoFromAPI
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:openstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(openstack, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = openstack.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
+
+          config = machine.provider_config
+
+          host = server.addresses[config.public_network_name].last['addr'] rescue nil
+          # Read the DNS info
+          return {
+            # Usually there should only be one public IP
+            :host => host,
+            :port => 22,
+            :username => config.ssh_username
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/read_ssh_info_from_cache.rb

@@ -0,0 +1,53 @@
+require "log4r"
+require "json"
+
+class ::Hash
+  def method_missing(name)
+    return self[name] if key? name
+    self.each { |k,v| return v if k.to_s.to_sym == name }
+    super.method_missing name
+  end
+end
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfoFromCache
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          ssh_info = read_ssh_info(env[:machine])
+          
+          if ssh_info and ssh_info[:host] != nil
+            env[:machine_ssh_info] = ssh_info
+          end 
+          @app.call(env)
+        end
+
+        def read_ssh_info(machine)
+          return nil if machine.id.nil?
+
+          cached_metadata_file = machine.data_dir.join("cached_metadata")
+
+          @logger.info("Loading cached metadata from #{cached_metadata_file}")
+          server = JSON.load(cached_metadata_file.read) rescue nil
+
+          config = machine.provider_config
+
+          host = server.addresses[config.public_network_name].last['addr'] rescue nil
+
+          return {
+            :host => host,
+            :port => 22,
+            :username => config.ssh_username
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/read_state.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    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_openstack::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:openstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(openstack, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = openstack.servers.get(machine.id)
+          if server.nil? || server.state == "DELETED"
+            # The machine can't be found
+            @logger.info("Machine not found or deleted, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.state.downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-cloud-provider/action/sync_folders.rb

@@ -0,0 +1,58 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # remote instance.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::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]
+            next if data[:disabled]
+
+            # 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_openstack.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", "--compress", "--delete",
+              "-e", "ssh -p #{ssh_info[:port]} -i '#{ssh_info[:private_key_path][0]}' -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null",
+              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