vagrant-skytap 0.1.1a

data/lib/vagrant-skytap/action.rb

@@ -0,0 +1,272 @@
+require "pathname"
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Skytap
+    module Action
+      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 InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env1, b1|
+            case result = env1[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b1.use MessageNotCreated
+            else
+              b1.use StopVm
+            end
+          end
+        end
+      end
+
+      # This action is called to suspend the remote machine.
+      def self.action_suspend
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env1, b1|
+            case result = env1[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b1.use MessageNotCreated
+            else
+              b1.use SuspendVm
+            end
+          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 ConfigValidate
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env, b1|
+            case existence_state = env[:result]
+            when :missing_environment, :no_vms
+              b1.use MessageNotCreated
+              b1.use DeleteEnvironment
+              next
+            when :missing_vm
+              b1.use MessageNotCreated
+              b1.use DeleteVm
+              next
+            end
+            b1.use Call, DestroyConfirm do |env2, b2|
+              if env2[:result]
+                case existence_state
+                when :one_of_many_vms
+                  b2.use DeleteVm
+                else
+                  b2.use DeleteEnvironment
+                end
+                b2.use ProvisionerCleanup if defined?(ProvisionerCleanup)
+              else
+                b2.use MessageWillNotDestroy
+              end
+            end
+          end
+          b.use PrepareNFSValidIds
+          b.use SyncedFolderCleanup
+        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 InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env, b1|
+            case result = env[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b1.use MessageNotCreated
+              next
+            end
+            b1.use Call, IsStopped do |env2, b2|
+              b2.use Call, IsRunning do |env3, b3|
+                b3.use RunVm unless env3[:result]
+              end
+
+              was_stopped = env2[:result]
+              if was_stopped
+                b2.use PrepareNFSSettings
+                b2.use PrepareNFSValidIds
+              end
+              b2.use Provision
+              if was_stopped
+                b2.use SyncedFolders
+              end
+            end
+          end
+        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 InitializeAPIClient
+          b.use FetchEnvironment
+          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 InitializeAPIClient
+          b.use FetchEnvironment
+          #TODO:NLA Can this whole action be removed?
+          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 InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env1, b1|
+            case result = env1[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b1.use MessageNotCreated
+            else
+              b1.use SSHExec
+            end
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env1, b1|
+            case result = env1[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b1.use MessageNotCreated
+            else
+              b1.use SSHRun
+            end
+          end
+        end
+      end
+
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use PrepareNFSSettings
+          b.use PrepareNFSValidIds
+          b.use Provision
+          b.use SyncedFolderCleanup
+          b.use SyncedFolders
+        end
+      end
+
+      def self.action_resume
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use action_up
+        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 HandleBox
+          b.use ConfigValidate
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env, b1|
+            case result = env[:result]
+            when :missing_environment
+              b1.use CreateEnvironment
+              b1.use MessageEnvironmentUrl
+            when :no_vms, :missing_vm
+              b1.use AddVmToEnvironment
+            else
+              next
+            end
+            b1.use StoreExtraData
+            b1.use SetUpVm
+          end
+          b.use Call, IsRunning do |env, b1|
+            if env[:result]
+              b1.use MessageAlreadyRunning
+              next
+            end
+
+            b1.use Call, IsStopped do |env2, b2|
+              if env2[:result]
+                b2.use UpdateHardware
+                b2.use SetHostname
+                b2.use action_prepare_boot
+              end
+
+              b2.use RunVm
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+          b.use Call, ExistenceCheck do |env, b2|
+            case env[:result]
+            when :missing_environment, :missing_vm, :no_vms
+              b2.use MessageNotCreated
+            else
+              b2.use action_halt
+              b2.use action_up
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :StoreExtraData, action_root.join("store_extra_data")
+      autoload :AddVmToEnvironment, action_root.join("add_vm_to_environment")
+      autoload :CreateEnvironment, action_root.join("create_environment")
+      autoload :DeleteEnvironment, action_root.join("delete_environment")
+      autoload :DeleteVm, action_root.join("delete_vm")
+      autoload :ExistenceCheck, action_root.join("existence_check")
+      autoload :FetchEnvironment, action_root.join("fetch_environment")
+      autoload :InitializeAPIClient, action_root.join("initialize_api_client")
+      autoload :IsRunning, action_root.join("is_running")
+      autoload :IsStopped, action_root.join("is_stopped")
+      autoload :IsSuspended, action_root.join("is_suspended")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageAlreadyRunning, action_root.join("message_already_running")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageEnvironmentUrl, action_root.join("message_environment_url")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+      autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunEnvironment, action_root.join("run_environment")
+      autoload :RunVm, action_root.join("run_vm")
+      autoload :SetHostname, action_root.join("set_hostname")
+      autoload :SetUpVm, action_root.join("set_up_vm")
+      autoload :StopVm, action_root.join("stop_vm")
+      autoload :SuspendVm, action_root.join("suspend_vm")
+      autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist
+      autoload :UpdateHardware, action_root.join("update_hardware")
+    end
+  end
+end

data/lib/vagrant-skytap/api/busyable.rb

@@ -0,0 +1,37 @@
+require 'timeout'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      module Busyable
+        WAIT_TIMEOUT = 600
+        WAIT_ITERATION_PERIOD = 1
+
+        def update_with_retry(attrs, path=nil)
+          retry_while_resource_busy do
+            resp = api_client.put(path || url, JSON.dump(attrs))
+            refresh(JSON.load(resp.body))
+            break
+          end
+        end
+
+        def retry_while_resource_busy(timeout=WAIT_TIMEOUT, &block)
+          begin
+            Timeout.timeout(timeout) do
+              loop do
+                break if env[:interrupted] # is this right?
+                begin
+                  yield
+                rescue Errors::ResourceBusy
+                end
+                sleep WAIT_ITERATION_PERIOD
+              end
+            end
+          rescue Timeout::Error => ex
+            raise Errors::InstanceReadyTimeout, timeout: timeout
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/api/client.rb

@@ -0,0 +1,127 @@
+require 'base64'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Client
+        attr_reader :config, :http
+
+        MAX_RATE_LIMIT_RETRIES = 3
+        DEFAULT_RETRY_AFTER_SECONDS = 10
+
+        def initialize(config)
+          @logger = Log4r::Logger.new("vagrant_skytap::api_client")
+
+          @config = config
+          uri = URI.parse(config.base_url)
+          @http = Net::HTTP.new(uri.host, uri.port)
+
+          #TODO:NLA Turn this on conditionally based on configuration value.
+          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          @http.use_ssl = uri.port == 443 || uri.scheme == 'https'
+        end
+
+        def get(path, options={})
+          req('GET', path, nil, options)
+        end
+
+        def post(path, body=nil, options={})
+          req('POST', path, body, options)
+        end
+
+        def put(path, body=nil, options={})
+          req('PUT', path, body, options)
+        end
+
+        def delete(path, options={})
+          req('DELETE', path, nil, options)
+        end
+
+        # +path+ may optionally include query and fragment parts
+        #
+        # +options+ are:
+        #   query: A string or hash of the query string
+        #   extra_headers: A hash of extra headers
+        def req(method, path, body, options={})
+          @logger.info("REST API call: #{method} #{path} #{'body: ' + body if body.present?}")
+
+          uri = URI.parse(path)
+
+          if qq = options[:query]
+            if qq.is_a?(Hash)
+              extra_query = qq.collect{|k,v| [k,v].join('=')}.join('&')
+            else
+              extra_query = qq.to_s
+            end
+          end
+
+          if (query = [uri.query, extra_query].compact.join('&')).present?
+            path = [uri.path, query].join('?')
+          end
+
+          headers = default_headers.merge(options[:extra_headers] || {})
+          tries = 0
+          retry_after = DEFAULT_RETRY_AFTER_SECONDS
+          begin
+            tries += 1
+            http.send_request(method, URI.encode(path), body, headers).tap do |ret|
+              @logger.debug("REST API response: #{ret.body}")
+              unless ret.code =~ /^2\d\d/
+                raise Errors::DoesNotExist, object_name: "Object '#{path}'" if ret.code == '404'
+                error_class = case ret.code
+                when '403'
+                  Errors::Unauthorized
+                when '422'
+                  Errors::UnprocessableEntity
+                when '423'
+                  Errors::ResourceBusy
+                when '429'
+                  retry_after = ret['Retry-After'] || DEFAULT_RETRY_AFTER_SECONDS
+                  Errors::RateLimited
+                else
+                  Errors::OperationFailed
+                end
+                raise error_class, err: error_string_from_body(ret)
+              end
+            end
+          rescue Errors::RateLimited => ex
+            raise if tries > MAX_RATE_LIMIT_RETRIES
+            @logger.info("Rate limited, wil retry in #{retry_after} seconds")
+            sleep retry_after.to_f + 0.1
+            retry
+          end
+        end
+
+        def error_string_from_body(resp)
+          resp = resp.body if resp.respond_to?(:body)
+          begin
+            resp = JSON.load(resp)
+            errors = resp['error'] || resp['errors']
+            errors = errors.join('; ') if errors.respond_to? :join
+          rescue
+            # treat non-JSON string as error text
+            errors = resp
+          end
+          errors if errors.present?
+        end
+
+        private
+
+
+        def default_headers
+          {
+            'Authorization' => auth_header,
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json'
+          }
+        end
+
+        def auth_header
+          "Basic #{Base64.encode64(config.username + ":" +
+                                   config.api_token)}".gsub("\n", '')
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/api/credentials.rb

@@ -0,0 +1,41 @@
+require 'vagrant-skytap/api/resource'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Credentials < Resource
+
+        attr_reader :vm
+        attr_reader :username, :password
+
+        reads :text
+
+        def initialize(attrs, vm, env)
+          super
+          @vm = vm
+
+          # Set username and password if we recognize them in the form
+          # "uname / pw."
+          uname, pw = text.split('/', 2).collect(&:strip)
+          if uname && pw
+            @username = uname
+            @password = pw
+          end
+        end
+
+        # Are the credentials in a form that we recognize?
+        def recognized?
+          !!(@username && @password)
+        end
+
+        def to_s
+          if recognized?
+            "#{username} / #{password}"
+          else
+            text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/api/environment.rb

@@ -0,0 +1,99 @@
+require 'json'
+require 'yaml'
+require 'vagrant-skytap/environment_properties'
+require 'vagrant-skytap/api/resource'
+require 'vagrant-skytap/api/vm'
+require 'vagrant-skytap/api/network'
+require_relative 'runstate_operations'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Environment < Resource
+        include RunstateOperations
+
+        RESOURCE_ROOT = '/configurations'
+        class << self
+          def create!(env, vm_url)
+            vm = Vm.fetch(env, vm_url)
+            check_vm_before_adding(env, vm)
+
+            resp = env[:api_client].post(RESOURCE_ROOT, JSON.dump(template_id: vm.template_id, vm_ids: [vm.id]))
+            fetch(env, resp['Location'])
+          end
+
+          def fetch(env, url)
+            resp = env[:api_client].get(url)
+            new(JSON.load(resp.body), env)
+          end
+
+          def properties(env)
+            EnvironmentProperties.read(env[:machine].env.local_data_path)
+          end
+
+          def check_vm_before_adding(env, vm)
+            raise Errors::SourceVmNotStopped, name: env[:machine].name, url: vm.url unless vm.stopped?
+          end
+        end
+
+
+        attr_reader :provider_config
+        attr_reader :vms, :networks
+
+        reads :id, :name, :vms, :networks, :region, :runstate, :url
+
+        def initialize(attrs, env)
+          super
+          @provider_config = env[:machine].provider_config
+        end
+
+        def vms
+          @vms ||= (get_api_attribute('vms') || []).collect do |vm_attrs|
+            Vm.new(vm_attrs, self, env)
+          end
+        end
+
+        def get_vm_by_id(id)
+          vms.find{|vm|vm.id == id}
+        end
+
+        def current_vm
+          vms.find(&:current_machine?)
+        end
+
+        def networks
+          @networks ||= (get_api_attribute('networks') || []).collect do |network_attrs|
+            Network.new(network_attrs, self, env)
+          end
+        end
+
+        def refresh(attrs)
+          @vms = nil
+          @networks = nil
+          super
+        end
+
+        def delete
+          retry_while_resource_busy do
+            api_client.delete(url)
+            break
+          end
+        end
+
+        def add_vm(vm_url)
+          vm = Vm.fetch(env, vm_url)
+          self.class.check_vm_before_adding(env, vm)
+          vm_ids = vms.collect(&:id)
+
+          update_with_retry(template_id: vm.template_id, vm_ids: [vm.id])
+          new_vm_ids = vms.collect(&:id) - vm_ids
+          get_vm_by_id(new_vm_ids.last)
+        end
+
+        def properties
+          @properties ||= EnvironmentProperties.new(env[:machine].env.local_data_path)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/api/interface.rb

@@ -0,0 +1,123 @@
+require 'vagrant-skytap/api/resource'
+require 'vagrant-skytap/api/public_ip'
+require 'vagrant-skytap/api/published_service'
+require_relative 'busyable'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Interface < Resource
+        include Busyable
+
+        attr_reader :vm
+
+        reads :id, :ip, :nat_addresses, :network_id, :public_ips, :services
+
+        def initialize(attrs, vm, env)
+          super
+          @vm = vm
+        end
+
+        def network
+          if network_id
+            vm.environment.networks.detect do |network|
+              network.id == network_id
+            end
+          end
+        end
+
+        def public_ips
+          @public_ips ||= (get_api_attribute('public_ips') || []).collect do |ip_attrs|
+            PublicIp.new(ip_attrs, self, env)
+          end
+        end
+
+        def published_services
+          @published_services ||= (get_api_attribute('services') || []).collect do |service_attrs|
+            PublishedService.new(service_attrs, self, env)
+          end
+        end
+
+        def url
+          "/configurations/#{vm.environment.id}/vms/#{vm.id}/interfaces/#{id}"
+        end
+
+        def available_ips
+          resp = api_client.get("#{url}/ips/available")
+          ip_attrs = JSON.load(resp.body)
+          ip_attrs.collect do |attrs|
+            PublicIp.new(attrs, nil, env)
+          end
+        end
+
+        def attachment_for(vpn)
+          network.try(:attachment_for, vpn)
+        end
+
+        def address_for(vpn)
+          if vpn.nat_enabled?
+            if info = vpn_nat_addresses.detect {|aa| aa['vpn_id'] == vpn.id}
+              info['ip_address']
+            end
+          elsif vpn_attachments.any? {|aa| aa.vpn['id'] == vpn.id}
+            ip
+          end
+        end
+
+        def vpn_attachments
+          if network
+            network.vpn_attachments
+          else
+            []
+          end
+        end
+
+        def vpn_nat_addresses
+          nat_addresses['vpn_nat_addresses'] || []
+        end
+
+        def nat_addresses
+          get_api_attribute('nat_addresses') || {}
+        end
+
+        def attach_public_ip(ip)
+          address = ip.is_a?(PublicIp) ? ip.address : ip.to_s
+          begin
+            resp = api_client.post("#{url}/ips", JSON.dump(ip: address))
+          rescue Errors::OperationFailed => ex
+            raise Errors::OperationFailed, err: 'Failed to attach public IP'
+          end
+        end
+
+        def published_service_choices
+          [uncreated_published_service_choice] +
+            published_services.collect(&:choice_for_setup)
+        end
+
+        def uncreated_published_service_choice
+          PublishedServiceChoice.uncreated_choice(env, self)
+        end
+
+        def create_published_service(internal_port)
+          #TODO:NLA Move this into PublishedService::create! Same with other places.
+          begin
+            resp = api_client.post("#{url}/services", JSON.dump(internal_port: internal_port))
+          rescue Errors::OperationFailed => ex
+            raise Errors::OperationFailed, err: 'Failed to create published service'
+          end
+
+          service_attrs = JSON.load(resp.body)
+          PublishedService.new(service_attrs, self, env).tap do |service|
+            published_services << service
+          end
+        end
+
+        def refresh(attrs)
+          @public_ips = nil
+          @published_services = nil
+          super
+        end
+      end
+    end
+  end
+end