vagrant-openstack 0.0.4

data/lib/vagrant-openstack/action/boot.rb

@@ -0,0 +1,150 @@
+require "fog"
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Action
+      # This creates the openstack server.
+      class Boot
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::create_server")
+        end
+
+        def call(env)
+          # Get the configs
+          config   = env[:machine].provider_config
+
+          # Find the flavor
+          env[:ui].info(I18n.t("vagrant_openstack.finding_flavor"))
+          flavor = find_matching(env[:os_connection].flavors.all, config.flavor)
+          raise Errors::NoMatchingFlavor if !flavor
+
+          # Find the image
+          env[:ui].info(I18n.t("vagrant_openstack.finding_image"))
+          images = env[:os_connection].images.all
+          if images.nil? || images.empty?
+            image = env[:os_connection].images.get(config.image)
+          else
+            image = find_matching(env[:os_connection].images.all, config.image)
+          end
+          raise Errors::NoMatchingImage if !image
+
+          # Figure out the name for the server
+          server_name = config.name || env[:machine].name
+
+          # If we're using the default keypair, then show a warning
+          default_key_path = Vagrant.source_root.join("keys/vagrant.pub").to_s
+          public_key_path  = File.expand_path(config.public_key_path, env[:root_path])
+
+          if default_key_path == public_key_path
+            env[:ui].warn(I18n.t("vagrant_openstack.warn_insecure_ssh"))
+          end
+
+          # 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}")
+          env[:ui].info(" -- Name: #{server_name}")
+
+          # Build the options for launching...
+          options = {
+            :flavor_ref   => flavor.id,
+            :image_ref    => image.id,
+            :name        => server_name,
+            }
+
+          if not config.security_groups.nil? and not config.security_groups.empty? then
+              options.store(:security_groups, config.security_groups)
+          end
+
+          if not config.keypair.nil?
+              options.store(:key_name, config.keypair)
+          else
+              options.store(:personality, [
+              {
+                :path     => "/root/.ssh/authorized_keys",
+                :contents => IO.read(public_key_path)
+              }
+            ])
+          end
+          # Create the server
+          server = env[:os_connection].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(I18n.t("vagrant_openstack.waiting_for_build"))
+          retryable(:on => Fog::Errors::TimeoutError, :tries => 200) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # Set the progress
+            env[:ui].clear_line
+            env[:ui].report_progress(server.progress, 100, false)
+
+            # Wait for the server to be ready
+            begin
+              server.wait_for(5) { ready? }
+            rescue RuntimeError => e
+              # If we don't have an error about a state transition, then
+              # we just move on.
+              raise if e.message !~ /should have transitioned/
+              raise Errors::CreateBadState, :state => server.state
+            end
+          end
+
+          if !env[:interrupted]
+            # Clear the line one more time so the progress is removed
+            env[:ui].clear_line
+
+            floating_ip = config.floating_ip
+            if floating_ip.nil?
+                floating_ip = env[:os_connection].allocate_address.body["floating_ip"]["ip"]
+            end
+
+            env[:ui].info(I18n.t("vagrant_openstack.associating_ip",
+                                :ip => floating_ip,
+                                :id => server.id))
+
+            env[:os_connection].associate_address(server.id, floating_ip)
+
+            # Wait for SSH to become available
+            env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
+            while true
+              # If we're interrupted then just back out
+              break if env[:interrupted]
+              break if env[:machine].communicate.ready?
+              sleep 2
+            end
+
+            env[:ui].info(I18n.t("vagrant_openstack.ready"))
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # 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|
+            return single if single.id == name
+            return single if single.name == name
+            return single if name.is_a?(Regexp) && name =~ single.name
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/connect.rb

@@ -0,0 +1,38 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Action
+      class Connect
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::connect")
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+
+          @logger.info("Connecting to OpenStack...")
+          #env[:os_connection] = OpenStack::Connection.create({
+          #                  :username => config.user,
+          #                  :api_key => config.password,
+          #                  :auth_method => "password",
+          #                  :auth_url => config.url,
+          #                  :authtenant_name => config.tenant,
+          #                  :service_type => "compute"})
+        
+          env[:os_connection] = Fog::Compute.new({
+            :provider => :openstack,
+            :openstack_tenant => config.tenant,
+            :openstack_api_key => config.password,
+            :openstack_auth_url => config.url,
+            :openstack_username => config.user,
+            :openstack_service_type  => "compute"
+          })                 
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/created.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderOpenStack
+    module Action
+      class Created
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Set the result to be true if the machine is created.
+          env[:result] = env[:machine].state.id != :not_created
+
+          # Call the next if we have one (but we shouldn't, since this
+          # middleware is built to run with the Call-type middlewares)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/delete.rb

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class Delete
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::delete")
+        end
+
+        def call(env)
+          os = env[:os_connection]
+          server = os.servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_openstack.deleting"))
+          server.destroy
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderOpenStack
+    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_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:os_connection], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(os, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = os.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
+          ssh_info = {
+            :host => get_ip(os, server.id),
+            :port => 22,
+            :username => config.ssh_username,
+          }
+
+          if config.ssh_private_key
+              ssh_info[:private_key_path] = config.ssh_private_key
+          end
+          
+          return ssh_info
+        end
+
+        def get_ip(os, id)
+            return os.list_all_addresses.body["floating_ips"]
+                     .select{|data| data['instance_id'] == id}
+                     .map{|addr| addr["ip"]}.first
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/release_ip.rb

@@ -0,0 +1,43 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderOpenStack
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReleaseIp
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          os = env[:os_connection]
+          config = env[:machine].provider_config
+
+          # Find the machine
+          server = os.servers.get(env[: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
+
+          ips = os.list_all_addresses.body["floating_ips"]
+                     .select{|data| data['instance_id'] == server.id}
+
+          ips.each do |ip|
+              # Do not release the ip if it was explicitly
+              # specified by the user.
+              if not ip["ip"] == config.floating_ip
+                os.release_address(ip["id"])
+              end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack/action/state.rb

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

data/lib/vagrant-openstack/action/sync_folder.rb

@@ -0,0 +1,57 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module ProviderOpenStack
+    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]
+
+            # 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", "-z",
+              "-e", "ssh -p #{ssh_info[:port]} -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-openstack/config.rb

@@ -0,0 +1,58 @@
+module VagrantPlugins
+  module ProviderOpenStack
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :url
+      attr_accessor :tenant
+      attr_accessor :user
+      attr_accessor :password
+
+
+      attr_accessor :name
+      attr_accessor :image
+      attr_accessor :flavor
+      attr_accessor :keypair
+      attr_accessor :security_groups
+      
+      attr_accessor :floating_ip
+
+      attr_accessor :ssh_port
+      attr_accessor :ssh_username
+      attr_accessor :public_key_path
+      attr_accessor :ssh_private_key
+
+      def initialize()
+
+        # OpenStack related parameters
+        @url               = UNSET_VALUE
+        @user              = UNSET_VALUE
+        @tenant            = UNSET_VALUE
+        @password          = UNSET_VALUE
+
+
+        # Nova / Instance related
+        # parameters
+        @name          = UNSET_VALUE
+        @image         = UNSET_VALUE
+        @flavor        = UNSET_VALUE
+        @keypair       = nil
+        @security_groups       = []
+
+
+        @floating_ip   = nil
+
+        # Instance access related
+        # parameters
+        @ssh_port        = 22
+        @ssh_username    = UNSET_VALUE
+
+        # Default to current's user id_rsa
+        # if it exists in the standard path
+        pub_users_key = File.expand_path("~/.ssh/id_rsa.pub")
+        @public_key_path = (File.exist?(pub_users_key) && pub_users_key) || UNSET_VALUE
+
+        priv_users_key = File.expand_path("~/.ssh/id_rsa")
+        @ssh_private_key = (File.exist?(priv_users_key) && priv_users_key) || UNSET_VALUE
+      end
+    end
+  end
+end