vagrant-openstack-plugin-tom 0.12.0

data/lib/vagrant-openstack-plugin/action/create_network_interfaces.rb

@@ -0,0 +1,52 @@
+require "log4r"
+
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class CreateNetworkInterfaces
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::create_network_interfaces")
+        end
+
+        def call(env)
+          networks_to_configure = []
+          env[:machine].config.vm.networks.each_with_index do |network, slot_number|
+            type = network[0]
+            original_options = network[1]
+            next if type != :private_network
+            next if original_options[:auto_config] === false
+            next if slot_number == 0
+
+            options = scoped_hash_override(original_options, :openstack)
+
+            @logger.info "Configuring interface slot_number #{slot_number} options #{options}"
+
+            network_to_configure = {
+              :interface => slot_number,
+            }
+
+            if options[:ip]
+              network_to_configure = {
+                :type    => :static,
+                :ip      => options[:ip],
+                :netmask => "255.255.255.0",
+              }.merge(network_to_configure)
+            else
+              network_to_configure[:type] = :dhcp
+            end
+
+            networks_to_configure.push(network_to_configure)
+          end
+          env[:ui].info I18n.t('vagrant.actions.vm.network.configuring')
+          env[:machine].guest.capability(:configure_networks, networks_to_configure)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/create_orchestration_stack.rb

@@ -0,0 +1,97 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class CreateOrchestrationStack
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            "vagrant_openstack::action::create_orchestration_stack")
+        end
+
+        def call(env)
+          # Get the config.
+          config = env[:machine].provider_config
+
+          # Are we going to handle orchestration stacks?
+          if not config.orchestration_stack_name
+            return @app.call(env)
+          end
+
+          # Create new fog orchestration service.
+          env[:openstack_orchestration] = Fog::Orchestration.new(
+            env[:fog_openstack_params])
+
+          # Check if stack is already created.
+          env[:openstack_orchestration].list_stacks.body['stacks'].each do |stack|
+            if config.orchestration_stack_name == stack['stack_name']
+              return @app.call(env)
+            end
+          end
+
+          # To avoid confusion, only one source for orchestration template
+          # should be set.
+          if [config.orchestration_cfn_template,
+              config.orchestration_cfn_template_file,
+              config.orchestration_cfn_template_url].count(nil) != 2
+            raise Errors::OrchestrationTemplateError,
+              :err => 'One source for orchestration template should be specified.'
+          end
+
+          # Prepare parameters for new orchestration stack.
+          # TODO: configurable parameters
+          stack_params = {
+            :disable_rollback   => false,
+            :timeout_in_minutes => 5,
+          }
+
+          # Set template source.
+          if config.orchestration_cfn_template
+            stack_params[:template] = config.orchestration_cfn_template
+          elsif config.orchestration_cfn_template_file
+            if not File.exist?(config.orchestration_cfn_template_file)
+              raise Errors::OrchestrationNoTemplateFileError,
+                :fname => config.orchestration_cfn_template_file
+            end
+
+            # Load template file content. Newlines can cause parse error of
+            # input JSON string.
+            stack_params[:template] = ''
+            File.open(config.orchestration_cfn_template_file) { |file|
+              file.each_line do |line|
+                stack_params[:template] << line
+              end
+            }
+          else
+            stack_params[:template_url] = config.orchestration_cfn_template_url
+          end
+
+          # Set template parameters.
+          stack_params[:parameters] = config.orchestration_cfn_template_parameters
+
+          # Create new stack.
+          env[:ui].info(I18n.t("vagrant_openstack.creating_orchestration_stack"))
+          stack = env[:openstack_orchestration].create_stack(
+            config.orchestration_stack_name, stack_params)
+
+          # Write UUID of newly created stack into file for later use (stack removal).
+          created_stacks_fname = env[:machine].data_dir + 'orchestration_stacks'
+          message = 'Saving information about created orchestration stack '
+          message << "#{config.orchestration_stack_name}, "
+          message << "UUID=#{stack.body['stack']['id']} "
+          message << "to file #{created_stacks_fname}."
+          @logger.info(message)
+
+          File.open(created_stacks_fname, 'a') do |file|
+            file.puts stack.body['stack']['id']
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/create_server.rb

@@ -0,0 +1,263 @@
+require "fog"
+require "log4r"
+
+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 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[: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
+
+          # Figure out the name for the server
+          server_name = config.server_name || env[:machine].name
+
+          # Build the options for launching...
+          options = {
+            :flavor_ref  => flavor.id,
+            :image_ref   => image.id,
+            :name        => server_name,
+            :key_name    => config.keypair_name,
+            :metadata    => config.metadata,
+            :user_data   => config.user_data,
+            :security_groups => config.security_groups,
+            :os_scheduler_hints => config.scheduler_hints,
+            :availability_zone => config.availability_zone
+          }
+          
+          # Fallback to only one network, otherwise `config.networks` overrides
+          unless config.networks
+            if config.network
+              config.networks = [ config.network ]
+            else
+              config.networks = []
+            end
+          end
+
+          # Find networks if provided
+          unless config.networks.empty?
+            env[:ui].info(I18n.t("vagrant_openstack.finding_network"))
+            options[:nics] = Array.new
+            config.networks.each_with_index do |os_network_name, i|
+
+              # Use the configured OpenStack network, if it exists.
+              os_network = find_matching(env[:openstack_network].networks, os_network_name)
+              if os_network
+                current = { :net_id => os_network.id }
+
+                # Match the OpenStack network to a corresponding
+                # config.vm.network option.  If there is one, use that for its
+                # IP address.
+                config_network = env[:machine].config.vm.networks[i]
+                if config_network
+                  ip_address = config_network[1][:ip]
+                  current[:v4_fixed_ip] = ip_address if ip_address
+                end
+
+                options[:nics] << current
+              end
+            end
+            env[:ui].info("options[:nics]: #{options[:nics]}")
+          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}")
+          config.networks.each do |n|
+            env[:ui].info(" -- Network: #{n}")
+          end
+          if config.security_groups
+            env[:ui].info(" -- Security Groups: #{config.security_groups}")
+          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(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? }
+              # Once the server is up and running assign a floating IP if we have one
+              floating_ip = config.floating_ip
+              # try to automatically allocate and  associate a floating IP
+              if floating_ip && floating_ip.to_sym == :auto
+                if config.floating_ip_pool
+                  env[:ui].info("Allocating floating IP address from pool: #{config.floating_ip_pool}")
+                  address = env[:openstack_compute].allocate_address(config.floating_ip_pool).body["floating_ip"]
+                  if address["ip"].nil?
+                    raise Errors::FloatingIPNotAllocated
+                  else
+                    floating_ip = address["ip"]
+                  end
+                else
+                  addresses = env[:openstack_compute].addresses
+                  free_floating = addresses.find_index {|a| a.fixed_ip.nil?}
+                  if free_floating.nil?
+                    raise Errors::FloatingIPNotFound
+                  else
+                    floating_ip = addresses[free_floating].ip
+                  end
+                end
+              end
+               
+              # try to automatically associate the next available unassigned ip in the given pool
+              if floating_ip && floating_ip.to_sym == :associate_unassigned
+                if config.floating_ip_pool
+                  env[:ui].info("Associating floating IP address from pool: #{config.floating_ip_pool}")
+                  addresses = env[:openstack_compute].addresses
+
+                  # grab the next available IP in this pool which is not currently allocated:
+                  address = env[:openstack_compute].addresses.find { |thisone|
+                      (thisone.attributes[:pool].eql? config.floating_ip_pool and thisone.attributes[:instance_id].nil?)
+                  }
+
+                  if address.nil?
+                    raise Errors::FloatingUnassignedIPNotFound
+                  else
+                      floating_ip = address.attributes[:ip]
+                  end
+                  result = env[:openstack_compute].associate_address(server.id,floating_ip)
+                  if result[:status] != 202
+                    raise Errors::FloatingIPFailedAssociate
+                  else
+                    env[:ui].info("Found and Associated floating IP address #{address.attributes[:ip]} from pool #{config.floating_ip_pool}")
+                  end
+                else
+                  raise Errors::FloatingUnassignedRequiresPool
+                end
+              end
+                
+              if floating_ip
+                floater = env[:openstack_compute].addresses.find { |thisone| thisone.ip.eql? floating_ip }
+                floater.server = server
+              end
+              
+              # Process disks if provided
+              volumes = Array.new
+              if config.disks && !config.disks.empty?
+                env[:ui].info(I18n.t("vagrant_openstack.creating_disks"))
+                config.disks.each do |disk|
+                  volume = env[:openstack_compute].volumes.all.find{|v| v.name ==
+                                                          disk["name"] and 
+                                                        v.description ==
+                                                          disk["description"] and
+                                                        v.size ==
+                                                          disk["size"] and
+                                                        v.ready? }
+                  if volume
+                    env[:ui].info("re-using volume: #{disk["name"]}")
+                    disk["volume_id"] = volume.id
+                  else
+                    env[:ui].info("creating volume: #{disk["name"]}")
+                    disk["volume_id"] = env[:openstack_compute].create_volume(
+                                         disk["name"], disk["description"], disk["size"]).\
+                                         data[:body]["volume"]["id"]
+                    volumes << { :id => disk["volume_id"] }
+                  end
+
+                  # mount points are not expected to be meaningful
+                  # add useful support if your cloud respects them
+                  begin
+                    # Assume instance has only one disk
+                    nova_offset = 1
+                    # Increase counter in case we have swap or ephemeral disks.
+                    if flavor.swap != 0
+                        nova_offset += 1
+                    end
+                    if flavor.ephemeral != 0
+                        nova_offset += 1
+                    end
+                    server.attach_volume(disk["volume_id"], "/dev/vd#{("c".."z").to_a[server.volume_attachments.length + nova_offset]}")
+                    server.wait_for{ volume_attachments.any?{|vol| vol["id"]==disk["volume_id"]} }
+                  rescue Excon::Errors::Error => e
+                    raise Errors::VolumeBadState, :volume => disk["name"], :state => e.message
+                  end
+                end
+              end
+
+              # store this so we can use it later
+              env[:floating_ip] = floating_ip
+              
+            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.downcase
+            end
+          end
+
+          if !env[:interrupted]
+            # Clear the line one more time so the progress is removed
+            env[:ui].clear_line
+
+            # Wait for SSH to become available
+            env[:ui].info(I18n.t("vagrant_openstack.waiting_for_ssh"))
+            while true
+              begin
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+              rescue Errno::ENETUNREACH, Errno::EHOSTUNREACH
+              end
+              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-plugin/action/delete_orchestration_stack.rb

@@ -0,0 +1,78 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class DeleteOrchestrationStack
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new(
+            "vagrant_openstack::action::delete_orchestration_stack")
+        end
+
+        def call(env)
+          # Get the config.
+          config = env[:machine].provider_config
+
+          # Load IDs for orchestration stacks created by vagrant and this
+          # project.
+          created_stacks_fname = env[:machine].data_dir + 'orchestration_stacks'
+
+          # Return if no action is needed. 
+          if not config.orchestration_stack_destroy or not File.exist?(created_stacks_fname)
+            env[:machine].id = nil
+            return @app.call(env)
+          end
+
+          # Create new fog orchestration service.
+          env[:openstack_orchestration] = Fog::Orchestration.new(
+            env[:fog_openstack_params])
+
+          # Load IDs of stacks to be deleted.
+          available_stacks = env[:openstack_orchestration].list_stacks.body['stacks']
+          stacks_to_delete = []
+          File.open(created_stacks_fname) { |file|
+            file.each_line do |stack_id|
+              stack = find_stack(available_stacks, stack_id.chomp!)
+              next if not stack
+              stacks_to_delete << stack
+            end
+          }
+
+          # Delete stacks.
+          if stacks_to_delete.length > 0
+            env[:ui].info(I18n.t("vagrant_openstack.deleting_orchestration_stacks"))
+          end
+
+          stacks_to_delete.each do |stack|
+            @logger.info("Removing orchestration stack #{stack['stack_name']} (#{stack['id']}).")
+            env[:openstack_orchestration].delete_stack(
+              stack['stack_name'], stack['id'])
+
+            stacks_from_file.delete(stack)
+          end
+
+          # Delete file holding created stack IDs.
+          @logger.info("Deleting file #{created_stacks_fname}.")
+          File.delete(created_stacks_fname)
+
+          env[:machine].id = nil
+          @app.call(env)
+        end
+
+        private
+
+        def find_stack(available_stacks, stack_id)
+          available_stacks.each do |stack|
+            if stack['id'] == stack_id
+              return stack
+            end
+          end
+          false
+        end
+      end
+    end
+  end
+end