vagrant-haipa 0.0.1 → 0.2.1

data/lib/vagrant-haipa/{actions → action}/wait_for_ip_address.rb

@@ -1,6 +1,6 @@
 module VagrantPlugins
   module Haipa
-    module Actions
+    module Action
       class WaitForIpAddress
         include Vagrant::Util::Retryable
 
@@ -11,12 +11,12 @@ module VagrantPlugins
         end
 
         def call(env)
-          # refresh machine state with provider and output ip address
+          # get machine state from driver and output ip address
           retryable(:tries => 20, :sleep => 10) do
             next if env[:interrupted]
 
-            haipa_machine = Provider.haipa_machine(@machine, :refresh => true)
-            addresses = haipa_machine['Networks'].map{|x| x['IpV4Addresses']}.flatten
+            haipa_machine =  @machine.provider.driver.machine('Networks')
+            addresses = haipa_machine.networks.map{|x| x.ip_v4addresses}.flatten
             addresses.reject! { |s| s.nil? || s.strip.empty? }
             address = addresses.first
             raise 'not ready' unless address

data/lib/vagrant-haipa/{actions.rb → action.rb}

@@ -1,85 +1,89 @@
 module VagrantPlugins
   module Haipa
-    module Actions
+    module Action
       include Vagrant::Action::Builtin
 
-      # This action is called to halt the remote machine.
-      def self.action_halt
+      # 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 Call, IsCreated do |env, b2|
-            unless env[:result]
-              b2.use MessageNotCreated
-              next
-            end
 
-            b2.use ConnectHaipa
-            b2.use StopMachine
+            if !env[:result]
+              b2.use SetName     
+              b2.use ConvergeMachine 
+            end
           end
+          b.use action_start
         end
       end
 
-      # This action is called to terminate the remote machine.
-      def self.action_destroy
+
+      # 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 Call, DestroyConfirm do |env, b2|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+      
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsRunning do |env, b2|
+            # If the machine is running, run the necessary provisioners
             if env[:result]
-              b2.use ConfigValidate
-              b2.use Call, IsCreated do |env2, b3|
-                unless env2[:result]
-                  b3.use MessageNotCreated
-                  next
-                end
-
-                b3.use ConnectHaipa
-                b3.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
-                b3.use DeleteMachine
-              end
-            else
-              b2.use MessageWillNotDestroy
+              b2.use action_provision
+              next
             end
+            
+            b2.use action_boot
           end
         end
       end
 
-      # This action is called when `vagrant provision` is called.
-      def self.action_provision
+      def self.action_stop
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
+
           b.use Call, IsCreated do |env, b2|
             unless env[:result]
               b2.use MessageNotCreated
               next
             end
-
-            b2.use Provision
-            b2.use SyncedFolderCleanup
-            b2.use SyncedFolders
+            
+            b2.use StopMachine
           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
+      def self.action_boot
         Vagrant::Action::Builder.new.tap do |b|
-          b.use ConfigValidate
-          b.use ConnectHaipa
-          b.use ReadSSHInfo
+          b.use Provision
+          b.use SyncedFolderCleanup
+          b.use SyncedFolders
+          b.use StartMachine
         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
+      # 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 ConnectHaipa
-          b.use ReadState
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncedFolderCleanup
+            b2.use SyncedFolders
+          end
         end
-      end
+      end      
 
       # This action is called to SSH into the machine.
       def self.action_ssh
@@ -118,92 +122,60 @@ module VagrantPlugins
         end
       end
 
-      def self.action_start
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use Call, IsState, :running do |env1, b1|
-            if env1[:result]
-              b1.use action_provision
-              next
-            end
-
-            b1.use Call, IsState, :paused do |env2, b2|
-              if env2[:result]
-                b2.use action_resume
-                next
-              end
-
-              b2.use Provision
-              b2.use StartMachine
-              b2.use WaitForCommunicator, [:running]
-              b2.use SyncedFolderCleanup
-              b2.use SyncedFolders
-              b2.use SetHostname
-            end
-          end
-        end
-      end
-
-      # This action is called to bring the box up from nothing.
-      def self.action_up
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
         Vagrant::Action::Builder.new.tap do |b|
-          # b.use HandleBox
-          b.use ConfigValidate
-          # b.use BoxCheckOutdated
-          b.use ConnectHaipa
-          b.use Call, IsCreated do |env1, b1|
-            if env1[:result]
-              b1.use Call, IsStopped do |env2, b2|
-                if env2[:result]
-                  b2.use action_start
-                else
-                  b2.use MessageAlreadyCreated
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b2.use Call, IsCreated do |env2, b3|
+                unless env2[:result]
+                  b3.use MessageNotCreated
+                  next
                 end
+
+                b3.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
+                b3.use DeleteMachine
               end
             else
-              b1.use SetName
-              b1.use CreateMachine
-              b1.use action_start
+              b2.use MessageWillNotDestroy
             end
           end
         end
-      end
+      end      
 
       def self.action_reload
         Vagrant::Action::Builder.new.tap do |b|
           b.use ConfigValidate
-          b.use ConnectHaipa
           b.use Call, IsCreated do |env, b2|
             unless 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
+            b2.use action_stop
+            b2.use ConvergeMachine
+            b2.use action_up
           end
         end
       end
 
       # The autoload farm
-      action_root = Pathname.new(File.expand_path('../actions', __FILE__))
-      autoload :ConnectHaipa, action_root.join('connect_haipa')
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :ReadState, action_root.join('read_state')
       autoload :IsCreated, action_root.join('is_created')
-      autoload :IsStopped, action_root.join('is_stopped')
+      autoload :IsRunning, action_root.join('is_running')
+      autoload :SetName, action_root.join('set_name')
+      autoload :ConvergeMachine, action_root.join('converge_machine')
+      autoload :DeleteMachine, action_root.join('delete_machine')
+      autoload :StartMachine, action_root.join('start_machine')      
+      autoload :StopMachine, action_root.join('stop_machine')      
+      autoload :WaitForIpAddress, action_root.join('wait_for_ip_address')
+      
       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 :CreateMachine, action_root.join('create_machine')
-      autoload :DeleteMachine, action_root.join('delete_machine')
-      autoload :StartMachine, action_root.join('start_machine')
-      autoload :StopMachine, action_root.join('stop_machine')
-      autoload :WaitForIpAddress, action_root.join('wait_for_ip_address')
-      autoload :SetName, action_root.join('set_name')
+
     end
   end
-end
+end

data/lib/vagrant-haipa/config.rb

@@ -1,36 +1,38 @@
 module VagrantPlugins
   module Haipa
     class Config < Vagrant.plugin('2', :config)
-      attr_accessor :token
-      attr_accessor :image
-      attr_accessor :region
-      attr_accessor :flavor
-
       attr_accessor :name
 
       attr_accessor :vm_config
-      attr_accessor :provision
+      attr_accessor :provision      
       
+      attr_accessor :client_id
+      attr_accessor :client_key_file
+      attr_accessor :identity_endpoint
+      attr_accessor :api_endpoint
 
-      def initialize
-        @token              = UNSET_VALUE
-        @image              = UNSET_VALUE
-        @region             = UNSET_VALUE
-        @flavor             = UNSET_VALUE
 
+      def initialize
+ 
         @name               = UNSET_VALUE
         @vm_config          = UNSET_VALUE
         @provision          = UNSET_VALUE
+
+        @client_id          = UNSET_VALUE
+        @client_key_file    = UNSET_VALUE
+        @identity_endpoint  = UNSET_VALUE
+        @api_endpoint       = UNSET_VALUE
       end
 
       def finalize!
-        @token              = ENV['DO_TOKEN'] if @token == UNSET_VALUE
-        @image              = 'ubuntu-14-04-x64' if @image == UNSET_VALUE
-        @region             = 'nyc2' if @region == UNSET_VALUE
-        @flavor             = 'default' if @size == UNSET_VALUE
         @name               = nil if @name == UNSET_VALUE
         @vm_config          = [] if @vm_config == UNSET_VALUE
         @provision          = [] if @provision == UNSET_VALUE
+
+        @client_id          = nil if @client_id == UNSET_VALUE
+        @client_key_file    = nil if @client_key_file == UNSET_VALUE
+        @identity_endpoint  = nil if @identity_endpoint == UNSET_VALUE
+        @api_endpoint       = nil if @api_endpoint == UNSET_VALUE     
       end
 
       def validate(machine)

data/lib/vagrant-haipa/driver.rb

@@ -0,0 +1,139 @@
+require 'haipa_compute'
+
+module VagrantPlugins
+  module Haipa
+    class Driver
+      include Vagrant::Util::Retryable
+      
+      @@compute_api = nil
+
+      def initialize(machine)
+        @machine = machine
+      end
+
+      # @return [::Haipa::Client::Compute::ApiConfiguration] Haipa Compute API
+      def compute_api
+        # If already connected to Haipa, just use it and don't connect
+        # again.
+        return @@compute_api if @@compute_api
+
+        config = @machine.provider_config
+        
+
+        @@compute_api = ::Haipa::Client::Compute.new({
+          client_id: config.client_id,
+          client_key_file: config.client_key_file,
+          identity_endpoint: config.identity_endpoint,
+          api_endpoint: config.api_endpoint
+        })
+
+        @@compute_api
+
+      end
+
+      
+      def read_state
+        return :not_created if @machine.id.nil?
+
+        haipa_machine = nil
+        begin
+          haipa_machine = compute_api.client.machines.get(@machine.id)
+        rescue ::Haipa::Client::HaipaOperationError => ex
+          if haipa_machine.nil?
+            # The machine can't be found
+            @logger.info('Machine not found or terminated, assuming it got destroyed.')
+            return :not_created
+          end
+        end
+
+        # Return the state
+        haipa_machine.status
+      end
+      
+      def machine_by_name(name)
+        haipa_machine_list = compute_api.client.machines.list(:filter=>"name eq '#{name}'")
+        haipa_machine_list.value.first
+      end
+
+      def machine(expand = nil)
+        compute_api.client.machines.get(@machine.id, :expand => expand)
+      end
+
+      def converge(env, name)
+
+        machine_config_hash = {
+          'name' => name,                           
+          'vm' => @machine.provider_config.vm_config,
+          "provisioning" => @machine.provider_config.provision   
+        }
+
+        machine_config = compute_api.deserialize(:MachineConfig, machine_config_hash)
+        operation = compute_api.client.machines.update_or_create(:config => machine_config)
+
+        wait_for_operation(env,operation) 
+      end
+
+      def start(env)
+        operation = compute_api.client.machines.start(@machine.id)
+        wait_for_operation(env,operation)
+      end
+
+      def stop(env)
+        operation = compute_api.client.machines.stop(@machine.id)
+        wait_for_operation(env,operation)
+      end
+
+      def delete(env)
+        operation = compute_api.client.machines.delete(@machine.id)
+        wait_for_operation(env,operation)
+      end
+
+      protected
+
+      def wait_for_operation(env,operation)
+        timestamp = '2018-09-01T23:47:17.50094+02:00'
+
+        operation_error = nil
+        
+        # wait for operation to be started
+        result = retryable(:tries => 20, :sleep => 5) do
+          # stop waiting if interrupted
+          next if env[:interrupted]
+
+          result = compute_api.client.operations.get(operation.id)
+          yield result if block_given?
+
+          raise 'Operation not started' if result.status == 'Queued'
+          result
+        end
+
+        if result.status == 'Running' then
+         
+          result = retryable(:tries => 20, :sleep => 5) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+
+            # check action status
+            result = compute_api.client.operations.get(operation.id, :expand => "LogEntries($filter=Timestamp gt #{timestamp})")
+
+            result.log_entries.each do |entry|
+              env[:ui].info(entry.message)
+              timestamp = entry.timestamp
+            end
+          
+            yield result if block_given?
+
+            raise 'Operation not completed' if result.status == 'Running'
+            result            
+          end          
+        end
+
+        raise "Operation failed: #{result.status_message}" if result.status == 'Failed'   
+        
+        #refresh operation result
+        compute_api.client.operations.get(operation.id)
+      end
+    end
+  end
+end
+      

data/lib/vagrant-haipa/errors.rb

@@ -1,41 +1,9 @@
 module VagrantPlugins
   module Haipa
-    module Errors
-      class HaipaError < Vagrant::Errors::VagrantError
-        error_namespace("vagrant_haipa.errors")
-      end
-
-      class APIStatusError < HaipaError
-        error_key(:api_status)
-      end
-
-      class JSONError < HaipaError
-        error_key(:json)
-      end
-
-      class ResultMatchError < HaipaError
-        error_key(:result_match)
-      end
-
-      class CertificateError < HaipaError
-        error_key(:certificate)
-      end
-
-      class LocalIPError < HaipaError
-        error_key(:local_ip)
-      end
-
-      class PublicKeyError < HaipaError
-        error_key(:public_key)
-      end
-
-      class RsyncError < HaipaError
-        error_key(:rsync)
-      end
-
-      class OperationNotCompleted < HaipaError
-        error_key(:rsync)
-      end      
+    class HaipaError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant_haipa.errors")
     end
+
   end
 end
+    

data/lib/vagrant-haipa/plugin.rb

@@ -1,22 +1,23 @@
 module VagrantPlugins
   module Haipa
-    class Plugin < Vagrant.plugin('2')
-      name 'Haipa'
+    class Plugin < Vagrant.plugin("2")
+      name "Haipa provider"
       description <<-DESC
-        This plugin installs a provider that allows Vagrant to manage
-        machines using Haipa's API.
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Haipa.
       DESC
 
       config(:haipa, :provider) do
         require_relative 'config'
         Config
-      end
+      end      
 
       provider(:haipa, parallel: true, defaultable: false, box_optional: true) do
         require_relative 'provider'
         Provider
       end
-
-    end
+  
+    end    
   end
 end
+