vagrant-cosmic 0.1.0

data/lib/vagrant-cosmic/action/start_instance.rb

@@ -0,0 +1,81 @@
+require "log4r"
+require "vagrant/util/retryable"
+require "vagrant-cosmic/util/timer"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::start_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          server = env[:cosmic_compute].servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_cosmic.starting"))
+
+          begin
+            server.start
+
+            domain                               = env[:machine].provider_config.domain_id
+            domain_config                        = env[:machine].provider_config.get_domain_config(domain)
+
+            # Wait for the instance to be ready first
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              tries = domain_config.instance_ready_timeout / 2
+
+              env[:ui].info(I18n.t("vagrant_cosmic.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) { ready? }
+                end
+              rescue Fog::Errors::TimeoutError
+                # Notify the user
+                raise Errors::InstanceReadyTimeout,
+                   :timeout => domain_config.instance_ready_timeout
+              end
+            end
+          rescue Fog::Cosmic::Compute::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for communicator to be ready.
+              communicator = env[:machine].config.vm.communicator
+              communicator = "SSH" if communicator.nil?
+              env[:ui].info(I18n.t("vagrant_cosmic.waiting_for_communicator", :communicator => communicator.to_s.upcase))
+              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_cosmic.ready"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cosmic::action::stop_instance")
+        end
+
+        def call(env)
+          server = env[:cosmic_compute].servers.get(env[:machine].id)
+
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t("vagrant_cosmic.already_status", :status => env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t("vagrant_cosmic.stopping"))
+            server.stop({'force' => !!env[:force_halt]})
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_cosmic::action::terminate_instance')
+        end
+
+        def call(env)
+          # Delete the Firewall rule
+          remove_firewall_rules(env)
+
+          # Disable Static NAT
+          remove_static_nat(env)
+
+          # Delete the Port forwarding rule
+          remove_portforwarding(env)
+
+          # Destroy the server and remove the tracking ID
+          if env[:machine].id.nil?
+            env[:ui].info(I18n.t('vagrant_cosmic.no_instance_found'))
+            return
+          else
+            server = env[:cosmic_compute].servers.get(env[:machine].id)
+
+            env[:ui].info(I18n.t('vagrant_cosmic.terminating'))
+
+            domain = env[:machine].provider_config.domain_id
+            domain_config = env[:machine].provider_config.get_domain_config(domain)
+            expunge_on_destroy = domain_config.expunge_on_destroy
+
+            options = {}
+            options['expunge'] = expunge_on_destroy
+
+            job = server.destroy(options)
+            wait_for_job_ready(env, job.id, 'Waiting for instance to be deleted')
+          end
+
+          remove_volumes(env)
+
+          # Delete the vmcredentials file
+          remove_stored_credentials(env)
+
+          # Remove keyname from cosmic
+          remove_generated_ssh_key(env)
+
+          env[:machine].id = nil
+
+          env[:ui].info(I18n.t('vagrant_cosmic.terminateinstance_done'))
+          @app.call(env)
+        end
+
+        def remove_volumes(env)
+          volumes_file = env[:machine].data_dir.join('volumes')
+          if volumes_file.file?
+            env[:ui].info(I18n.t('vagrant_cosmic.deleting_volumes'))
+            File.read(volumes_file).each_line do |line|
+              volume_id = line.strip
+              begin
+                resp = env[:cosmic_compute].detach_volume({:id => volume_id})
+                job_id = resp['detachvolumeresponse']['jobid']
+                wait_for_job_ready(env, job_id)
+              rescue Fog::Cosmic::Compute::Error => e
+                if e.message =~ /Unable to execute API command detachvolume.*entity does not exist/
+                  env[:ui].warn(I18n.t('vagrant_cosmic.detach_volume_failed', message: e.message))
+                else
+                  raise Errors::FogError, :message => e.message
+                end
+              end
+              resp = env[:cosmic_compute].delete_volume({:id => volume_id})
+              env[:ui].warn(I18n.t('vagrant_cosmic.detach_volume_failed', volume_id: volume_id)) unless resp['deletevolumeresponse']['success'] == 'true'
+            end
+            volumes_file.delete
+          end
+        end
+
+        def remove_generated_ssh_key(env)
+          sshkeyname_file = env[:machine].data_dir.join('sshkeyname')
+          if sshkeyname_file.file?
+            env[:ui].info(I18n.t('vagrant_cosmic.ssh_key_pair_removing'))
+            sshkeyname = ''
+            File.read(sshkeyname_file).each_line do |line|
+              sshkeyname = line.strip
+            end
+
+            begin
+              response = env[:cosmic_compute].delete_ssh_key_pair(name: sshkeyname)
+              env[:ui].warn(I18n.t('vagrant_cosmic.ssh_key_pair_no_success_removing', name: sshkeyname)) unless response['deletesshkeypairresponse']['success'] == 'true'
+            rescue Fog::Cosmic::Compute::Error => e
+              env[:ui].warn(I18n.t('vagrant_cosmic.errors.fog_error', :message => e.message))
+            end
+            sshkeyname_file.delete
+          end
+        end
+
+        def remove_stored_credentials(env)
+          vmcredentials_file = env[:machine].data_dir.join('vmcredentials')
+          vmcredentials_file.delete if vmcredentials_file.file?
+        end
+
+        def remove_portforwarding(env)
+          env[:ui].info(I18n.t('vagrant_cosmic.deleting_port_forwarding_rule'))
+          port_forwarding_file = env[:machine].data_dir.join('port_forwarding')
+          if port_forwarding_file.file?
+            File.read(port_forwarding_file).each_line do |line|
+              rule_id = line.strip
+              begin
+                resp = env[:cosmic_compute].delete_port_forwarding_rule({:id => rule_id})
+                job_id = resp['deleteportforwardingruleresponse']['jobid']
+                wait_for_job_ready(env, job_id)
+              rescue Fog::Cosmic::Compute::Error => e
+                if e.message =~ /Unable to execute API command deleteportforwardingrule.*entity does not exist/
+                  env[:ui].warn(" -- Failed to delete portforwarding rule: #{e.message}")
+                else
+                  raise Errors::FogError, :message => e.message
+                end
+
+              end
+            end
+            port_forwarding_file.delete
+          end
+
+          # Delete the Communicator Port forwording public port file
+          # Delete the RDP Port forwording public port file
+          %w(pf_public_port pf_public_rdp_port).each do |pf_filename|
+            pf_file = env[:machine].data_dir.join(pf_filename)
+            pf_file.delete if pf_file.file?
+          end
+        end
+
+        def remove_static_nat(env)
+          env[:ui].info(I18n.t('vagrant_cosmic.disabling_static_nat'))
+          static_nat_file = env[:machine].data_dir.join('static_nat')
+          if static_nat_file.file?
+            File.read(static_nat_file).each_line do |line|
+              ip_address_id = line.strip
+              begin
+                options = {
+                    :command => 'disableStaticNat',
+                    :ipaddressid => ip_address_id
+                }
+                resp = env[:cosmic_compute].request(options)
+                job_id = resp['disablestaticnatresponse']['jobid']
+                wait_for_job_ready(env, job_id)
+              rescue Fog::Cosmic::Compute::Error => e
+                raise Errors::FogError, :message => e.message
+              end
+            end
+            static_nat_file.delete
+          end
+        end
+
+        def remove_firewall_rules(env)
+          env[:ui].info(I18n.t('vagrant_cosmic.deleting_firewall_rule'))
+          firewall_file = env[:machine].data_dir.join('firewall')
+          if firewall_file.file?
+            File.read(firewall_file).each_line do |line|
+              line_items=line.split(",").collect(&:strip)
+              rule_id = line_items[0]
+              type_string = line_items[1]
+
+              if type_string == 'firewallrule'
+                command_string = 'deleteFirewallRule'
+                response_string = 'deletefirewallruleresponse'
+              else
+                command_string = 'deleteNetworkACL'
+                response_string = 'deletenetworkaclresponse'
+              end
+
+              begin
+                options = {
+                    command: command_string,
+                    id: rule_id
+                }
+                resp = env[:cosmic_compute].request(options)
+                job_id = resp[response_string]['jobid']
+                wait_for_job_ready(env, job_id)
+              rescue Fog::Cosmic::Compute::Error => e
+                if e.message =~ /Unable to execute API command deletefirewallrule.*entity does not exist/
+                  env[:ui].warn(" -- Failed to delete #{type_string}: #{e.message}")
+                else
+                  raise Errors::FogError, :message => e.message
+                end
+              end
+            end
+            firewall_file.delete
+          end
+        end
+
+        def wait_for_job_ready(env, job_id, message=nil)
+          while true
+            response = env[:cosmic_compute].query_async_job_result({:jobid => job_id})
+            if response['queryasyncjobresultresponse']['jobstatus'] != 0
+              break
+            else
+              env[:ui].info(message) if message
+              sleep 2
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-cosmic/util/timer"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, pname, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics]                      ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [p.class.to_s, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/wait_for_state.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_cosmic::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info(I18n.t("vagrant_cosmic.already_status", :status => @state))
+          else
+            @logger.info("Waiting for machine to reach state #{@state}")
+            begin
+              Timeout.timeout(@timeout) do
+                until env[:machine].state.id == @state
+                  sleep 2
+                end
+              end
+            rescue Timeout::Error
+              env[:result] = false # couldn't reach state in time
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Cosmic
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_cosmic.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/action.rb

@@ -0,0 +1,210 @@
+require "pathname"
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Cosmic
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectCosmic
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b.use Call, IsCreated do |env2, b3|
+                if !env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+              end
+              b2.use ConnectCosmic
+              b2.use TerminateInstance
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncedFolders
+          end
+        end
+      end
+
+      # This action is called to read the WinRM info of the machine. The
+      # resulting state is expected to be put into the `:machine_winrm_info`
+      # key.
+      def self.action_read_rdp_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use ReadRdpInfo
+        end
+      end
+
+      # This action is called to read the WinRM info of the machine. The
+      # resulting state is expected to be put into the `:machine_winrm_info`
+      # key.
+      def self.action_read_winrm_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use ReadWinrmInfo
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncedFolders
+          b.use WarnNetworks
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if env2[:result]
+                  b2.use action_prepare_boot
+                  b2.use StartInstance # restart this instance
+                else
+                  b2.use MessageAlreadyCreated # TODO write a better message
+                end
+              end
+            else
+              b1.use action_prepare_boot
+              b1.use RunInstance # launch a new instance
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectCosmic
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, :stopped, 120 do |env2, b3|
+              if env2[:result]
+                b3.use action_up
+              else
+                # TODO we couldn't reach :stopped, what now?
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectCosmic, action_root.join("connect_cosmic")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsStopped, action_root.join("is_stopped")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadWinrmInfo, action_root.join("read_winrm_info")
+      autoload :ReadRdpInfo, action_root.join("read_rdp_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
+      autoload :TimedProvision, action_root.join("timed_provision")
+      autoload :WaitForState, action_root.join("wait_for_state")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+    end
+  end
+end

data/lib/vagrant-cosmic/capabilities/rdp.rb

@@ -0,0 +1,12 @@
+module VagrantPlugins
+  module Cosmic
+    module Cap
+      class Rdp
+        def self.rdp_info(machine)
+          env = machine.action('read_rdp_info')
+          env[:machine_rdp_info]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cosmic/capabilities/winrm.rb

@@ -0,0 +1,12 @@
+module VagrantPlugins
+  module Cosmic
+    module Cap
+      class WinRM
+        def self.winrm_info(machine)
+          env = machine.action('read_winrm_info')
+          env[:machine_winrm_info]
+        end
+      end
+    end
+  end
+end