vagrant-mcs 0.6.0

data/example_box/README.md

@@ -0,0 +1,13 @@
+# Vagrant MCS Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `mcs` provider.
+To turn this into a box:
+
+```
+$ tar cvzf mcs.box ./metadata.json ./Vagrantfile
+```
+
+This box works by using Vagrant's built-in Vagrantfile merging to setup
+defaults for MCS. These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/example_box/metadata.json

@@ -0,0 +1,3 @@
+{
+    "provider": "mcs"
+}

data/lib/vagrant-mcs/action/connect_mcs.rb

@@ -0,0 +1,51 @@
+require "fog"
+require "mos_sdk"
+require "log4r"
+
+module VagrantPlugins
+  module MCS
+    module Action
+      # This action connects to MCS, verifies credentials work, and
+      # puts the MCS connection object into the `:mcs_compute` key
+      # in the environment.
+      class ConnectMCS
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_mcs::action::connect_mcs")
+        end
+
+        def call(env)
+          # 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)
+
+          # Build the fog config
+          fog_config = {
+              :provider => :mcs,
+              :region => region
+          }
+          if region_config.use_iam_profile
+            fog_config[:use_iam_profile] = true
+          else
+            fog_config[:mcs_access_key_id] = region_config.access_key_id
+            fog_config[:mcs_secret_access_key] = region_config.secret_access_key
+            fog_config[:mcs_secret_url] = region_config.secret_access_url
+            #fog_config[:mcs_session_token] = region_config.session_token
+          end
+
+          fog_config[:endpoint] = region_config.endpoint if region_config.endpoint
+          fog_config[:version] = region_config.version if region_config.version
+
+          @logger.info("Connecting to MCS...")
+          #env[:mcs_compute] = Fog::Compute.new(fog_config)
+          env[:mcs_compute] = MosSdk::Client.new(region_config.access_key_id,region_config.secret_access_key,region_config.secret_access_url)
+          # env[:mcs_elb]     = Fog::MCS::ELB.new(fog_config.except(:provider, :endpoint))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mcs/action/elb_deregister_instance.rb

@@ -0,0 +1,24 @@
+require 'vagrant-mcs/util/elb'
+
+module VagrantPlugins
+  module MCS
+    module Action
+      # This registers instance in ELB
+      class ElbDeregisterInstance
+        include ElasticLoadBalancer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_mcs::action::elb_deregister_instance")
+        end
+
+        def call(env)
+          if elb_name = env[:machine].provider_config.elb
+            deregister_instance env, elb_name, env[:machine].id
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mcs/action/elb_register_instance.rb

@@ -0,0 +1,24 @@
+require 'vagrant-mcs/util/elb'
+
+module VagrantPlugins
+  module MCS
+    module Action
+      # This registers instance in ELB
+      class ElbRegisterInstance
+        include ElasticLoadBalancer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_mcs::action::elb_register_instance")
+        end
+
+        def call(env)
+          @app.call(env)
+          if elb_name = env[:machine].provider_config.elb
+            register_instance env, elb_name, env[:machine].id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mcs/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module MCS
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      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-mcs/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module MCS
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      class IsStopped
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :stopped
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mcs/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module MCS
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_mcs.already_status", :status => "created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mcs/action/message_not_created.rb

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

data/lib/vagrant-mcs/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module MCS
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_mcs.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+require "log4r"
+require 'vagrant/util/template_renderer'
+require 'vagrant-mcs/util/timer'
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module MCS
+    module Action
+      # This action packages a running mcs-based server into an
+      # mcs-based vagrant box. It does so by burning the associated
+      # vagrant-mcs 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_mcs::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[:mcs_compute].servers.get(env[:machine].id)
+
+            env[:ui].info(I18n.t("vagrant_mcs.packaging_instance", :instance_id => server.id))
+            
+            # Make the request to MCS 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 mcs 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_mcs.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_mcs.packaging_instance_complete", :time_seconds => env[:metrics]["instance_ready_time"].to_i))
+          rescue Fog::Compute::MCS::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-mcs_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 mcs-vagrant templates
+        def template_root
+          MCS.source_root.join("templates")
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "log4r"
+
+module VagrantPlugins
+  module MCS
+    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_mcs::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:mcs_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(mcs, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = mcs.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
+
+          return { :host => host_value, :port => 22 }
+        end
+      end
+    end
+  end
+end