vagrant-mos 0.8.53 → 0.8.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19d0897f6817f014641fc53677b9209ee4ead668
-  data.tar.gz: c0983c99bd9e8a25058082a77f6c877b52f5b035
+  metadata.gz: ab6993e3c1608d77c180c670d922df230a5d47ec
+  data.tar.gz: 2da4fee620e4c28cc1d4eba2e6650ac1d36dee8d
 SHA512:
-  metadata.gz: 562cf8094996ee2f8446671e162350db42e27a4ab94931bf26390f16a622e7ac0921e09a8f2ea42824b148eba617a2c6e7389ac1b9d157cd08d16a333139abfc
-  data.tar.gz: 251260cbf24872cd692ac92713f0534e240080f64ae2f6e7773129ee4f2a2bcae309dfa34c263d935dd05aa324b54ee6deff0a3f2b49751560b74783426e0f56
+  metadata.gz: 24293e0504bfcc62dd675ae6adbeface5339e4f1ec30fc208ed80f5b4648635d46f2cd41d2d3153f78cfc9bfeff8e520a715a9f13529f0a098a3edef9a84f5be
+  data.tar.gz: f9d92d0566d8d9daedfbb77ad6668567d06c615d5061e8fa69d1e1ad6194618b7f6442d34e6a507c08f8424a4912b14c827b117dbca42ac1ae8d766daf5eb57b

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

@@ -15,9 +15,6 @@ module VagrantPlugins
           @app = app
           @logger = Log4r::Logger.new("vagrant_mos::action::connect_mos")
         end
-        #li= Client.new('c9b13af321f247a496f925d70ce001b3','7013bacdb1d44e0a851aa8786f742596','https://192.168.2.33:8883')
-        #puts li.get_balance
-
 
         def call(env)
           # Get the region we're going to booting up in
@@ -26,31 +23,10 @@ module VagrantPlugins
           # Get the configs
           region_config = env[:machine].provider_config.get_region_config(region)
 
-=begin
-          # Build the fog config
-          fog_config = {
-              :provider => :mos,
-              :region => region
-          }
-          if region_config.use_iam_profile
-            fog_config[:use_iam_profile] = true
-          else
-            fog_config[:mos_access_key_id] = region_config.access_key_id
-            fog_config[:mos_secret_access_key] = region_config.secret_access_key
-            fog_config[:mos_secret_url] = region_config.secret_access_url
-          end
-
-          fog_config[:endpoint] = region_config.endpoint if region_config.endpoint
-          fog_config[:version] = region_config.version if region_config.version
-=end
-
           @logger.info("Connecting to MOS...")
           #env[:mos_compute] = Fog::Compute.new(fog_config)
           env[:mos_compute] = Client.new(region_config.access_key_id, region_config.secret_access_key, region_config.secret_access_url)
-          #require "mos-sdk"
-          #include MOS
 
-          # env[:mos_elb]     = Fog::MOS::ELB.new(fog_config.except(:provider, :endpoint))
           @app.call(env)
         end
       end

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

@@ -9,7 +9,6 @@ module VagrantPlugins
         end
 
         def call(env)
-          puts env[:machine].state.id
           env[:result] = env[:machine].state.id == "ready"
           @app.call(env)
         end

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

@@ -22,8 +22,7 @@ module VagrantPlugins
 
           # 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.")
@@ -47,16 +46,11 @@ module VagrantPlugins
               @logger.info("SSH host attribute not found #{attr_name}")
             end
           end
-          #puts 2
 
           if !host_value
             host_value = server["ipAddresses"]
           end
-          #puts "ssh_host_attribute: #{ssh_host_attribute}"
-          #puts "ssh_attrs: #{ssh_attrs}"
-          #puts server["ipAddresses"]
-          #puts host_value
-          #puts 3
+
           return {:host => host_value, :port => 22}
         end
       end

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

@@ -21,13 +21,7 @@ module VagrantPlugins
           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? || [:"deleting"].include?(server["status"])
             # The machine can't be found
             @logger.info("Machine not found or terminated, assuming it got destroyed.")
@@ -35,8 +29,6 @@ module VagrantPlugins
             return :not_created
           end
 
-          # Return the state
-          # puts server["status"]
           return server["status"]
 
         end

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

@@ -49,11 +49,6 @@ module VagrantPlugins
             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}")
@@ -65,14 +60,12 @@ module VagrantPlugins
           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 = {
@@ -100,34 +93,9 @@ module VagrantPlugins
 
           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::InternalMosError,
-              :error => e.message,
-              :response => e.response.body
-
-=end
+            raise Errors::MosError, :message => e.message
           end
 
           # Immediately save the ID since it is created at this point.
@@ -139,14 +107,19 @@ module VagrantPlugins
 
             env[:ui].info(I18n.t("vagrant_mos.waiting_for_ready"))
             begin
-              retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+              retryable(:on => Errors::InstanceReadyTimeout, :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? }
+                if(server["status"] == "running")
+                  break
+                else
+                  sleep(2)
+                end
               end
-            rescue Fog::Errors::TimeoutError
+            rescue Errors::InstanceReadyTimeout
               # Delete the instance
               terminate(env)
 
@@ -158,12 +131,6 @@ module VagrantPlugins
 
           @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.
@@ -210,72 +177,6 @@ module VagrantPlugins
           !rules.select { |r| (r["fromPort"]..r["toPort"]).include?(port) }.empty?
         end
 
-=begin
-        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
-=end
-
         def terminate(env)
           destroy_env = env.dup
           destroy_env.delete(:interrupted)

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

@@ -11,13 +11,10 @@ module VagrantPlugins
         end
 
         def call(env)
-          #server = env[:mos_compute].servers.get(env[:machine].id)
-          #server = (env[:mos_compute].describe_instances([env[:machine].id]))["Instance"]
           if env[:machine].state.id == "ready"
             env[:ui].info(I18n.t("vagrant_mos.already stopped"))
           else
             env[:ui].info(I18n.t("vagrant_mos.stopping"))
-            #server.stop(!!env[:force_halt])
             env[:mos_compute].stop_instance(env[:machine].id)
           end
 

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

@@ -12,40 +12,13 @@ module VagrantPlugins
         end
 
         def call(env)
-          #server         = env[:mos_compute].describe_instances(env[:machine].id)
-          #region         = env[:machine].provider_config.region
-          #region_config  = env[:machine].provider_config.get_region_config(region)
-
-          #elastic_ip     = region_config.elastic_ip
-
-          # Release the elastic IP
-          #ip_file = env[:machine].data_dir.join('elastic_ip')
-          #if ip_file.file?
-          #  release_address(env,ip_file.read)
-          #  ip_file.delete
-          #end
-
           # Destroy the server and remove the tracking ID
           env[:ui].info(I18n.t("vagrant_mos.terminating"))
-          #server.destroy
           env[:mos_compute].terminate_instance(env[:machine].id)
           env[:machine].id = nil
 
           @app.call(env)
         end
-
-        # Release an elastic IP address
-        def release_address(env,eip)
-          h = JSON.parse(eip)
-          # Use association_id and allocation_id for VPC, use public IP for EC2
-          if h['association_id']
-            env[:mos_compute].disassociate_address(nil,h['association_id'])
-            env[:mos_compute].release_address(h['allocation_id'])
-          else
-            env[:mos_compute].disassociate_address(h['public_ip'])
-            env[:mos_compute].release_address(h['public_ip'])
-          end
-        end
       end
     end
   end

data/lib/vagrant-mos/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module MOS
-    VERSION = '0.8.53'
+    VERSION = '0.8.54'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-mos
 version: !ruby/object:Gem::Version
-  version: 0.8.53
+  version: 0.8.54
 platform: ruby
 authors:
 - yangcs2009
@@ -118,7 +118,6 @@ files:
 - lib/vagrant-mos/action/message_already_created.rb
 - lib/vagrant-mos/action/message_not_created.rb
 - lib/vagrant-mos/action/message_will_not_destroy.rb
-- lib/vagrant-mos/action/package_instance.rb
 - lib/vagrant-mos/action/read_ssh_info.rb
 - lib/vagrant-mos/action/read_state.rb
 - lib/vagrant-mos/action/run_instance.rb

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

@@ -1,193 +0,0 @@
-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)
-            server = (env[:mos_compute].describe_instances([env[:machine].id]))["Instance"]
-
-            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