vagrant-mos 0.8.39

data/lib/vagrant-mos/action/package_instance.rb

@@ -0,0 +1,192 @@
+require "log4r"
+require 'vagrant/util/template_renderer'
+require 'vagrant-mos/util/timer'
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # This action packages a running mos-based server into an
+      # mos-based vagrant box. It does so by burning the associated
+      # vagrant-mos server instance, into an AMI via fog. Upon
+      # successful AMI burning, the action will create a .box tarball
+      # writing a Vagrantfile with the fresh AMI id into it.
+
+      # Vagrant itself comes with a general package action, which 
+      # this plugin action does call. The general action provides
+      # the actual packaging as well as other options such as
+      # --include for including additional files and --vagrantfile
+      # which is pretty much not useful here anyway.
+
+      # The virtualbox package plugin action was loosely used
+      # as a model for this class.
+
+      class PackageInstance < Vagrant::Action::General::Package
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_mos::action::package_instance")
+          env["package.include"] ||= []
+          env["package.output"] ||= "package.box"
+        end
+
+        alias_method :general_call, :call
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # This block attempts to burn the server instance into an AMI
+          begin
+            # Get the Fog server object for given machine
+            server = env[:mos_compute].servers.get(env[:machine].id)
+
+            env[:ui].info(I18n.t("vagrant_mos.packaging_instance", :instance_id => server.id))
+            
+            # Make the request to MOS to create an AMI from machine's instance
+            ami_response = server.service.create_image server.id, "#{server.tags["Name"]} Package - #{Time.now.strftime("%Y%m%d-%H%M%S")}", ""
+
+            # Find ami id
+            @ami_id = ami_response.data[:body]["imageId"]
+            
+            # Attempt to burn the mos instance into an AMI within timeout
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              
+              # Get the config, to set the ami burn timeout
+              region = env[:machine].provider_config.region
+              region_config = env[:machine].provider_config.get_region_config(region)
+              tries = region_config.instance_package_timeout / 2
+
+              env[:ui].info(I18n.t("vagrant_mos.burning_ami", :ami_id => @ami_id))
+
+              # Check the status of the AMI every 2 seconds until the ami burn timeout has been reached
+              begin
+                retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                  # If we're interrupted don't worry about waiting
+                  next if env[:interrupted]
+
+                  # Need to update the ami_obj on each cycle
+                  ami_obj = server.service.images.get(@ami_id)
+
+                  # Wait for the server to be ready, raise error if timeout reached 
+                  server.wait_for(2) { 
+                    if ami_obj.state == "failed"
+                      raise Errors::InstancePackageError, 
+                        ami_id: ami_obj.id,
+                        err: ami_obj.state
+                      return
+                    else
+                      # Successful AMI burn will result in true here
+                      ami_obj.ready?
+                    end
+                  }
+                end
+              rescue Fog::Errors::TimeoutError
+                # Notify the user upon timeout
+                raise Errors::InstancePackageTimeout,
+                  timeout: region_config.instance_package_timeout
+              end
+            end
+            env[:ui].info(I18n.t("vagrant_mos.packaging_instance_complete", :time_seconds => env[:metrics]["instance_ready_time"].to_i))
+          rescue Fog::Compute::MOS::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Handles inclusions from --include and --vagrantfile options
+          setup_package_files(env)
+
+          # Setup the temporary directory for the tarball files
+          @temp_dir = env[:tmp_path].join(Time.now.to_i.to_s)
+          env["export.temp_dir"] = @temp_dir
+          FileUtils.mkpath(env["export.temp_dir"])
+
+          # Create the Vagrantfile and metadata.json files from templates to go in the box
+          create_vagrantfile(env)
+          create_metadata_file(env)
+
+          # Just match up a couple environmental variables so that
+          # the superclass will do the right thing. Then, call the
+          # superclass to actually create the tarball (.box file)
+          env["package.directory"] = env["export.temp_dir"]
+          general_call(env)
+          
+          # Always call recover to clean up the temp dir
+          clean_temp_dir
+        end
+
+        protected
+
+        # Cleanup temp dir and files
+        def clean_temp_dir
+          if @temp_dir && File.exist?(@temp_dir)
+            FileUtils.rm_rf(@temp_dir)
+          end
+        end
+
+        # This method generates the Vagrantfile at the root of the box. Taken from 
+        # VagrantPlugins::ProviderVirtualBox::Action::PackageVagrantfile
+        def create_vagrantfile env
+          File.open(File.join(env["export.temp_dir"], "Vagrantfile"), "w") do |f|
+            f.write(TemplateRenderer.render("vagrant-mos_package_Vagrantfile", {
+              region: env[:machine].provider_config.region,
+              ami: @ami_id,
+              template_root: template_root
+            }))
+          end
+        end
+
+        # This method generates the metadata.json file at the root of the box.
+        def create_metadata_file env
+          File.open(File.join(env["export.temp_dir"], "metadata.json"), "w") do |f|
+            f.write(TemplateRenderer.render("metadata.json", {
+              template_root: template_root
+            }))
+          end
+        end
+
+        # Sets up --include and --vagrantfile files which may be added as optional
+        # parameters. Taken from VagrantPlugins::ProviderVirtualBox::Action::SetupPackageFiles
+        def setup_package_files(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+              file: from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+        end
+
+        # Used to find the base location of mos-vagrant templates
+        def template_root
+          MOS.source_root.join("templates")
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require "log4r"
+
+module VagrantPlugins
+  module MOS
+    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_mos::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:mos_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(mos, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = (mos.describe_instances([machine.id]))["Instance"]
+          #puts server
+          #server = mos.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
+
+          # read attribute override
+          ssh_host_attribute = machine.provider_config.
+              get_region_config(machine.provider_config.region).ssh_host_attribute
+          # default host attributes to try. NOTE: Order matters!
+          ssh_attrs = [:public_ip_address, :dns_name, :private_ip_address]
+          ssh_attrs = (Array(ssh_host_attribute) + ssh_attrs).uniq if ssh_host_attribute
+          # try each attribute, get out on first value
+          host_value = nil
+
+          while !host_value and attr_name = ssh_attrs.shift
+            begin
+              host_value = server.send(attr_name)
+            rescue NoMethodError
+              @logger.info("SSH host attribute not found #{attr_name}")
+            end
+          end
+          #puts 2
+
+          if !host_value
+            host_value = server["ipAddresses"]
+          end
+          #puts server
+          #puts server["ipAddresses"]
+          #puts host_value
+          #puts 3
+          return {:host => host_value, :port => 22}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "log4r"
+
+module VagrantPlugins
+  module MOS
+    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_mos::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:mos_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(mos, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          #puts mos
+          #puts machine.id
+          server = (mos.describe_instances([machine.id]))["Instance"]
+          #puts "read_state"
+          #puts server
+          #puts "finish read_state"
+          #server = mos.servers.get(machine.id)
+          if server.nil? || [:"shutting-down", :terminated].include?(server["status"])
+            # 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
+          puts server["status"]
+          return server["status"]
+
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mos/action/run_instance.rb

@@ -0,0 +1,287 @@
+require "log4r"
+require 'json'
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-mos/util/timer'
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_mos::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the region we're going to booting up in
+          region = env[:machine].provider_config.region
+
+          # Get the configs
+          region_config = env[:machine].provider_config.get_region_config(region)
+          ami = region_config.ami
+          availability_zone = region_config.availability_zone
+          instance_type = region_config.instance_type
+          keypair = region_config.keypair_name
+          private_ip_address = region_config.private_ip_address
+          security_groups = region_config.security_groups
+          subnet_id = region_config.subnet_id
+          tags = region_config.tags
+          user_data = region_config.user_data
+          block_device_mapping = region_config.block_device_mapping
+          elastic_ip = region_config.elastic_ip
+          terminate_on_shutdown = region_config.terminate_on_shutdown
+          iam_instance_profile_arn = region_config.iam_instance_profile_arn
+          iam_instance_profile_name = region_config.iam_instance_profile_name
+          monitoring = region_config.monitoring
+          ebs_optimized = region_config.ebs_optimized
+          associate_public_ip = region_config.associate_public_ip
+
+          # If there is no keypair then warn the user
+          if !keypair
+            env[:ui].warn(I18n.t("vagrant_mos.launch_no_keypair"))
+          end
+
+          # If there is a subnet ID then warn the user
+          if subnet_id && !elastic_ip
+            env[:ui].warn(I18n.t("vagrant_mos.launch_vpc_warning"))
+          end
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_mos.launching_instance"))
+          env[:ui].info(" -- Type: #{instance_type}")
+          env[:ui].info(" -- AMI: #{ami}")
+          env[:ui].info(" -- Region: #{region}")
+          env[:ui].info(" -- Availability Zone: #{availability_zone}") if availability_zone
+          env[:ui].info(" -- Keypair: #{keypair}") if keypair
+          env[:ui].info(" -- Subnet ID: #{subnet_id}") if subnet_id
+          env[:ui].info(" -- IAM Instance Profile ARN: #{iam_instance_profile_arn}") if iam_instance_profile_arn
+          env[:ui].info(" -- IAM Instance Profile Name: #{iam_instance_profile_name}") if iam_instance_profile_name
+          env[:ui].info(" -- Private IP: #{private_ip_address}") if private_ip_address
+          env[:ui].info(" -- Elastic IP: #{elastic_ip}") if elastic_ip
+          env[:ui].info(" -- User Data: yes") if user_data
+          env[:ui].info(" -- Security Groups: #{security_groups.inspect}") if !security_groups.empty?
+          env[:ui].info(" -- User Data: #{user_data}") if user_data
+          env[:ui].info(" -- Block Device Mapping: #{block_device_mapping}") if block_device_mapping
+          env[:ui].info(" -- Terminate On Shutdown: #{terminate_on_shutdown}")
+          env[:ui].info(" -- Monitoring: #{monitoring}")
+          env[:ui].info(" -- EBS optimized: #{ebs_optimized}")
+          env[:ui].info(" -- Assigning a public IP address in a VPC: #{associate_public_ip}")
+
+          options = {
+              :availability_zone => availability_zone,
+              :flavor_id => instance_type,
+              :image_id => ami,
+              :key_name => keypair,
+              :private_ip_address => private_ip_address,
+              :subnet_id => subnet_id,
+              :iam_instance_profile_arn => iam_instance_profile_arn,
+              :iam_instance_profile_name => iam_instance_profile_name,
+              :tags => tags,
+              :user_data => user_data,
+              :block_device_mapping => block_device_mapping,
+              :instance_initiated_shutdown_behavior => terminate_on_shutdown == true ? "terminate" : nil,
+              :monitoring => monitoring,
+              :ebs_optimized => ebs_optimized,
+              :associate_public_ip => associate_public_ip
+          }
+          if !security_groups.empty?
+            security_group_key = options[:subnet_id].nil? ? :groups : :security_group_ids
+            options[security_group_key] = security_groups
+            env[:ui].warn(I18n.t("vagrant_mos.warn_ssh_access")) unless allows_ssh_port?(env, security_groups, subnet_id)
+          end
+
+          begin
+            # todo
+            #puts options
+            #puts options['image_id']
+            #puts options[:flavor_id]
+            #puts options["key_name"]
+            server = env[:mos_compute].create_instance(options[:image_id], options[:flavor_id], nil, nil, options[:key_name], datadisk=9, bandwidth=2)
+            #server = env[:mos_compute].create_instance("320bbeb9-788f-4e7b-86af-7ea377b6a99e", "C2_M2", nil, nil, nil, datadisk=9, bandwidth=2)
+              #server = env[:mos_compute].servers.create(options)
+            #puts server
+          rescue Exception => e
+            raise Errors::FogError, :message
+=begin
+          rescue Fog::Compute::MOS::NotFound => e
+            # Invalid subnet doesn't have its own error so we catch and
+            # check the error message here.
+            if e.message =~ /subnet ID/
+              raise Errors::FogError,
+                :message => "Subnet ID not found: #{subnet_id}"
+            end
+
+            raise
+          rescue Fog::Compute::MOS::Error => e
+            raise Errors::FogError, :message => e.message
+          rescue Excon::Errors::HTTPStatusError => e
+            raise Errors::InternalFogError,
+              :error => e.message,
+              :response => e.response.body
+
+=end
+          end
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server['instanceId']
+
+          # Wait for the instance to be ready first
+          env[:metrics]["instance_ready_time"] = Util::Timer.time do
+            tries = region_config.instance_ready_timeout / 2
+
+            env[:ui].info(I18n.t("vagrant_mos.waiting_for_ready"))
+            begin
+              retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                # If we're interrupted don't worry about waiting
+                next if env[:interrupted]
+
+                # Wait for the server to be ready
+                #server.wait_for(2, 5) { ready? }
+              end
+            rescue Fog::Errors::TimeoutError
+              # Delete the instance
+              terminate(env)
+
+              # Notify the user
+              raise Errors::InstanceReadyTimeout,
+                    timeout: region_config.instance_ready_timeout
+            end
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          # Allocate and associate an elastic IP if requested
+          if elastic_ip
+            domain = subnet_id ? 'vpc' : 'standard'
+            do_elastic_ip(env, domain, server, elastic_ip)
+          end
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_mos.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
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_mos.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def allows_ssh_port?(env, test_sec_groups, is_vpc)
+          port = 22 # TODO get ssh_info port
+          test_sec_groups = ["default"] if test_sec_groups.empty? # MOS default security group
+                    # filter groups by name or group_id (vpc)
+          groups = test_sec_groups.map do |tsg|
+            env[:mos_compute].security_groups.all.select { |sg| tsg == (is_vpc ? sg.group_id : sg.name) }
+          end.flatten
+                    # filter TCP rules
+          rules = groups.map { |sg| sg.ip_permissions.select { |r| r["ipProtocol"] == "tcp" } }.flatten
+                    # test if any range includes port
+          !rules.select { |r| (r["fromPort"]..r["toPort"]).include?(port) }.empty?
+        end
+
+        def do_elastic_ip(env, domain, server, elastic_ip)
+          if elastic_ip =~ /\d+\.\d+\.\d+\.\d+/
+            begin
+              address = env[:mos_compute].addresses.get(elastic_ip)
+            rescue
+              handle_elastic_ip_error(env, "Could not retrieve Elastic IP: #{elastic_ip}")
+            end
+            if address.nil?
+              handle_elastic_ip_error(env, "Elastic IP not available: #{elastic_ip}")
+            end
+            @logger.debug("Public IP #{address.public_ip}")
+          else
+            begin
+              allocation = env[:mos_compute].allocate_address(domain)
+            rescue
+              handle_elastic_ip_error(env, "Could not allocate Elastic IP.")
+            end
+            @logger.debug("Public IP #{allocation.body['publicIp']}")
+          end
+
+          # Associate the address and save the metadata to a hash
+          h = nil
+          if domain == 'vpc'
+            # VPC requires an allocation ID to assign an IP
+            if address
+              association = env[:mos_compute].associate_address(server.id, nil, nil, address.allocation_id)
+            else
+              association = env[:mos_compute].associate_address(server.id, nil, nil, allocation.body['allocationId'])
+              # Only store release data for an allocated address
+              h = {:allocation_id => allocation.body['allocationId'], :association_id => association.body['associationId'], :public_ip => allocation.body['publicIp']}
+            end
+          else
+            # Standard EC2 instances only need the allocated IP address
+            if address
+              association = env[:mos_compute].associate_address(server.id, address.public_ip)
+            else
+              association = env[:mos_compute].associate_address(server.id, allocation.body['publicIp'])
+              h = {:public_ip => allocation.body['publicIp']}
+            end
+          end
+
+          unless association.body['return']
+            @logger.debug("Could not associate Elastic IP.")
+            terminate(env)
+            raise Errors::FogError,
+                  :message => "Could not allocate Elastic IP."
+          end
+
+          # Save this IP to the data dir so it can be released when the instance is destroyed
+          if h
+            ip_file = env[:machine].data_dir.join('elastic_ip')
+            ip_file.open('w+') do |f|
+              f.write(h.to_json)
+            end
+          end
+        end
+
+        def handle_elastic_ip_error(env, message)
+          @logger.debug(message)
+          terminate(env)
+          raise Errors::FogError,
+                :message => message
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end