vagrant-skytap 0.1.1a

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

@@ -0,0 +1,40 @@
+require 'vagrant-skytap/api/resource'
+require 'vagrant-skytap/api/vpn_attachment'
+require 'vagrant-skytap/util/subnet'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Network < Resource
+        attr_reader :environment
+
+        reads :id, :subnet, :vpn_attachments
+
+        def initialize(attrs, environment, env)
+          super
+          @environment = environment
+        end
+
+        def refresh(attrs)
+          @vpn_attachments = nil
+          super
+        end
+
+        def vpn_attachments
+          @vpn_attachments ||= (get_api_attribute('vpn_attachments') || []).collect do |att_attrs|
+            VpnAttachment.new(att_attrs, self, env)
+          end
+        end
+
+        def subnet
+          Util::Subnet.new(get_api_attribute('subnet'))
+        end
+
+        def attachment_for(vpn)
+          vpn = vpn.id unless vpn.is_a?(String)
+          vpn_attachments.detect {|att| att.vpn['id'] == vpn}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'vagrant-skytap/api/resource'
+
+#TODO:NLA Move this to another class, properly namespaced.
+class PublicIpChoice
+  attr_reader :env, :ip, :iface, :execution
+
+  def initialize(env, ip, iface)
+    @env = env
+    @ip = ip
+    @iface = iface
+    @execution = AttachmentExecution.make(env, ip, iface)
+  end
+
+  def to_s
+    "#{execution.verb} public IP: #{ip.address}".tap do |ret|
+      if ip.deployed?
+        ret << ' (attached and deployed to another VM)'
+      elsif ip.attached?
+        ret << ' (attached to another VM)'
+      end
+    end
+  end
+
+  def choose
+    execution.execute
+
+    host = ip.address
+    port = 22 #TODO:NLA Use constant.
+    [host, port]
+  end
+
+  def valid?
+    true
+  end
+
+  class AttachmentExecution
+    def self.make(env, ip, iface)
+      if ip.attached?
+        UseAttachmentExecution.new(env, ip, iface)
+      else
+        AttachAndUseExecution.new(env, ip, iface)
+      end
+    end
+
+    attr_reader :env, :ip, :iface
+
+    def initialize(env, ip, iface)
+      @env = env
+      @ip = ip
+      @iface = iface
+    end
+  end
+
+  class UseAttachmentExecution < AttachmentExecution
+    def verb
+      'Use'
+    end
+
+    def execute
+      # No-op
+    end
+  end
+
+  class AttachAndUseExecution < AttachmentExecution
+    def verb
+      'Attach and use'
+    end
+
+    def execute
+      iface.attach_public_ip(ip)
+    end
+  end
+end
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class PublicIp < Resource
+        attr_reader :interface
+
+        reads :id, :address, :nics
+
+        # +interface+ may be nil; i.e., this IP isn't attached to anything.
+        def initialize(attrs, interface, env)
+          super
+          @interface = interface
+        end
+
+        def choice_for_setup(iface)
+          PublicIpChoice.new(env, self, iface)
+        end
+
+        def attached?
+          interface || nics.present?
+        end
+
+        def deployed?
+          nics.any? {|nic_attrs| nic_attrs['deployed']}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'vagrant-skytap/api/resource'
+
+#TODO:NLA Move this to another class, properly namespaced.
+class PublishedServiceChoice
+  attr_reader :env, :iface, :service, :execution
+
+  def self.uncreated_choice(env, iface)
+    new(env, iface, nil)
+  end
+
+  def initialize(env, iface, service=nil)
+    @env = env
+    @iface = iface
+    @service = service
+    @execution = ServiceExecution.make(env, iface, service)
+  end
+
+  def to_s
+    execution.message
+  end
+
+  def choose
+    execution.execute
+    @service = execution.service
+    [service.external_ip, service.external_port]
+  end
+
+  def valid?
+    service.nil? || service.internal_port == 22 #TODO:NLA Use constant
+  end
+
+  class ServiceExecution
+    def self.make(env, iface, service=nil)
+      if service
+        UseServiceExecution.new(env, iface, service)
+      else
+        CreateAndUseServiceExecution.new(env, iface, service)
+      end
+    end
+
+    attr_reader :env, :iface, :service
+
+    def initialize(env, iface, service)
+      @env = env
+      @iface = iface
+      @service = service
+    end
+  end
+
+  class UseServiceExecution < ServiceExecution
+    def message
+      "Use published service #{service.external_ip}:#{service.external_port}"
+    end
+
+    def execute
+      # No-op
+    end
+  end
+
+  class CreateAndUseServiceExecution < ServiceExecution
+    def message
+      'Create and use published service'
+    end
+
+    def execute
+      @service = iface.create_published_service(22) #TODO:NLA Use constant
+    end
+  end
+end
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class PublishedService < Resource
+        attr_reader :interface
+
+        reads :id, :internal_port, :external_ip, :external_port
+
+        def initialize(attrs, interface, env)
+          super
+          @interface = interface
+        end
+
+        def choice_for_setup
+          PublishedServiceChoice.new(env, self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative 'specified_attributes'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Resource
+        include SpecifiedAttributes
+
+        attr_reader :attrs, :env
+
+        class << self
+          def resource_name
+            name.split("::").last
+          end
+        end
+
+        def initialize(*args)
+          @attrs = args.first
+          @env = args.last
+        end
+
+        def url
+          "/#{self.class.resource_name.downcase}s/#{id}"
+        end
+
+        def reload
+          resp = api_client.get(url)
+          refresh(JSON.load(resp.body))
+        end
+
+        def refresh(attrs)
+          @attrs = attrs
+          self
+        end
+
+        private
+
+        def api_client
+          env[:api_client]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'timeout'
+require_relative 'busyable'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      module RunstateOperations
+        include Busyable
+
+        def run!
+          set_runstate :running
+        end
+
+        def suspend!
+          set_runstate :suspended
+        end
+
+        def stop!
+          set_runstate :stopped
+        end
+
+        def poweroff!
+          set_runstate :halted, :stopped
+        end
+
+        def set_runstate(new_runstate, completed_runstate = nil)
+          completed_runstate ||= new_runstate
+          update_with_retry(runstate: new_runstate)
+          wait_for_runstate(completed_runstate) unless runstate == completed_runstate
+        end
+
+        def wait_until_ready
+          wait_for_runstate :ready
+        end
+
+        def wait_for_runstate(expected_runstate)
+          expected_runstate = expected_runstate.to_s
+          retry_while_resource_busy do
+            unless reload.busy?
+              break if runstate == expected_runstate || expected_runstate == 'ready'
+            end
+          end
+        end
+
+        def runstate
+          get_api_attribute('runstate')
+        end
+
+        def busy?
+          runstate == 'busy'
+        end
+
+        def stopped?
+          runstate == 'stopped'
+        end
+
+        def running?
+          runstate == 'running'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module VagrantPlugins
+  module Skytap
+    module API
+      module SpecifiedAttributes
+        module ClassMethods
+          def reads(*names)
+            @readables ||= []
+
+            names.each do |name|
+              define_method(name) do
+                get_api_attribute(name.to_s)
+              end
+            end
+          end
+        end
+
+        def get_api_attribute(name)
+          attrs.fetch(name.to_s, nil)
+        end
+
+        def self.included(base)
+          base.singleton_class.send(:include, ClassMethods)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'vagrant-skytap/api/resource'
+require 'vagrant-skytap/api/interface'
+require 'vagrant-skytap/api/credentials'
+require_relative 'runstate_operations'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Vm < Resource
+        include RunstateOperations
+
+        attr_reader :provider_config
+        attr_reader :environment
+
+        reads :id, :interfaces, :credentials
+
+        class << self
+          def fetch(env, url)
+            resp = env[:api_client].get(url)
+            new(JSON.load(resp.body), env[:environment], env)
+          end
+
+          def current_vm(env)
+            if (environment = env[:environment]) && (machine = env[:machine]) && machine.id
+              environment.get_vm_by_id(machine.id)
+            end
+          end
+        end
+
+        def initialize(attrs, environment, env)
+          super
+          @environment = environment
+          @provider_config = env[:machine].provider_config
+        end
+
+        def refresh(attrs)
+          @interfaces = nil
+          @credentials = nil
+          super
+        end
+
+        def interfaces
+          @interfaces ||= (get_api_attribute('interfaces') || []).collect do |iface_attrs|
+            Interface.new(iface_attrs, self, env)
+          end
+        end
+
+        def credentials
+          @credentials ||= (get_api_attribute('credentials') || []).collect do |cred_attrs|
+            Credentials.new(cred_attrs, self, env)
+          end
+        end
+
+        def hardware
+          get_api_attribute('hardware')
+        end
+
+        def template_id
+          get_api_attribute('template_url') =~ /templates\/(\d+)/
+          $1
+        end
+
+        def delete
+          begin
+            retry_while_resource_busy do
+              api_client.delete(url)
+              break
+            end
+          rescue Errors::OperationFailed => ex
+            raise Errors::OperationFailed, err: 'Failed to delete VM'
+          end
+        end
+
+        def machine
+          env[:machine]
+        end
+
+        def current_machine?
+          id && machine && id == machine.id
+        end
+
+        def communicate_ready?
+          current_machine? && machine.communicate.ready?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'vagrant-skytap/util/subnet'
+require 'vagrant-skytap/api/resource'
+require 'vagrant-skytap/api/vpn_attachment'
+
+#TODO:NLA Move this to another class, properly namespaced.
+class VpnChoice
+  attr_reader :env, :vpn, :vm, :iface, :attachment, :execution
+
+  def initialize(env, vpn, vm)
+    @env = env
+    @vpn = vpn
+    @vm = vm
+    @iface = vm.interfaces.select(&:network).tap do |ifaces|
+      unless vpn.nat_enabled?
+        ifaces.select! {|i| vpn.subsumes?(i.network) }
+      end
+    end.first
+    @execution = AttachmentExecution.make(env, vpn, iface)
+  end
+
+  def to_s
+    "#{execution.verb} VPN: #{vpn.name}".tap do |ret|
+      if vpn.nat_enabled?
+        ret << " (NAT-enabled)"
+      else
+        ret << " (local subnet: #{vpn.local_subnet})"
+      end
+    end
+  end
+
+  def choose
+    execution.execute
+
+    @iface = vm.reload.interfaces.detect{|i| i.id == iface.id }
+    host = iface.address_for(vpn)
+    port = 22 #TODO:NLA Use constant
+
+    [host, port]
+  end
+
+  def valid?
+    true
+  end
+
+  class AttachmentExecution
+    attr_reader :env, :vpn, :iface, :attachment
+
+    def self.make(env, vpn, iface)
+      attachment = iface.attachment_for(vpn)
+
+      if attachment.try(:connected?)
+        UseAttachmentExecution.new(env, vpn, iface, attachment)
+      elsif attachment
+        ConnectAttachmentExecution.new(env, vpn, iface, attachment)
+      else
+        CreateAttachmentExecution.new(env, vpn, iface)
+      end
+    end
+
+    def initialize(env, vpn, iface, attachment=nil)
+      @env = env
+      @vpn = vpn
+      @iface = iface
+      @attachment = attachment
+    end
+
+    def verb
+      raise NotImplementedError.new('Must override')
+    end
+
+    def execute
+      raise NotImplementedError.new('Must override')
+    end
+  end
+
+  class UseAttachmentExecution < AttachmentExecution
+    def verb
+      'Use'
+    end
+
+    def execute
+      # No-op
+    end
+  end
+
+  class ConnectAttachmentExecution < AttachmentExecution
+    def verb
+      'Connect to and use'
+    end
+
+    def execute
+      attachment.connect!
+    end
+  end
+
+  class CreateAttachmentExecution < AttachmentExecution
+    def verb
+      'Attach to and use'
+    end
+
+    def execute
+      @attachment = VagrantPlugins::Skytap::API::VpnAttachment.create(iface.network, vpn, env)
+      @attachment.connect!
+    end
+  end
+end
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class Vpn < Resource
+
+        class << self
+          def all(env, options = {})
+            resp = env[:api_client].get('/vpns', options)
+            vpn_attrs = JSON.load(resp.body)
+            vpn_attrs.collect {|attrs| new(attrs, env)}
+          end
+
+          def fetch(env, url, options = {})
+            resp = env[:api_client].get(url, options)
+            new(JSON.load(resp.body), env)
+          end
+        end
+
+        reads :id, :local_subnet, :name, :nat_local_subnet
+
+        def choice_for_setup(vm)
+          VpnChoice.new(env, self, vm)
+        end
+
+        def nat_enabled?
+          !!nat_local_subnet
+        end
+
+        def subsumes?(network)
+          subnet.subsumes?(network.subnet)
+        end
+
+        def subnet
+          Util::Subnet.new(local_subnet)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'vagrant-skytap/api/resource'
+require_relative 'busyable'
+
+module VagrantPlugins
+  module Skytap
+    module API
+      class VpnAttachment < Resource
+        include Busyable
+
+        attr_reader :network
+
+        reads :connected, :network, :vpn
+
+        def self.create(network, vpn, env)
+          path = "#{base_url(network.id, network.environment.id)}?id=#{vpn.id}"
+          resp = env[:api_client].post(path)
+          body = JSON.load(resp.body)
+          new(body, network, env)
+        end
+
+        def self.base_url(network_id, environment_id)
+          "/configurations/#{environment_id}/networks/#{network_id}/vpns"
+        end
+
+        def initialize(attrs, network, env)
+          super
+          @network = network
+        end
+
+        def url
+          environment_id = network['configuration_id']
+          network_id = network['id']
+          vpn_id = vpn['id']
+          "#{self.class.base_url(network_id, environment_id)}/#{vpn_id}"
+        end
+
+        def nat_enabled?
+          vpn['nat_enabled']
+        end
+
+        def connected?
+          !!connected
+        end
+
+        def connect!
+          update_with_retry(connected: true)
+          raise Errors::VpnConnectionFailed unless connected?
+        end
+
+        def vpn_name
+          vpn['name']
+        end
+      end
+    end
+  end
+end
+