vagrant-haipa 0.0.1

data/lib/vagrant-haipa/actions/delete_machine.rb

@@ -0,0 +1,31 @@
+require 'vagrant-haipa/helpers/client'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class DeleteMachine
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::DeleteMachine')
+        end
+
+        def call(env)
+          # submit delete machine request
+          result = @client.delete("/odata/Machines(#{@machine.id})")
+
+          env[:ui].info I18n.t('vagrant_haipa.info.destroying')
+          @client.wait_for_event(env, result['Id'])
+
+          # set the machine id to nil to cleanup local vagrant state
+          @machine.id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::haipa::is_created')
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class IsStopped
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::haipa::is_stopped')
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :Stopped
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/message_already_created.rb

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

data/lib/vagrant-haipa/actions/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class MessageNotCreated
+        def initialize(app, _)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_haipa.info.not_created')
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class MessageWillNotDestroy
+        def initialize(app, _)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_haipa.info.will_not_destroy', name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/modify_provision_path.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class ModifyProvisionPath
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger =
+            Log4r::Logger.new('vagrant::haipa::modify_provision_path')
+        end
+
+        def call(env)
+          # check if provisioning is enabled
+          enabled = true
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+          return @app.call(env) if !enabled
+
+          username = @machine.ssh_info()[:username]
+
+          # change ownership of the provisioning path recursively to the
+          # ssh user
+          #
+          # TODO submit patch to vagrant to set appropriate permissions
+          # based on ssh username
+          @machine.config.vm.provisioners.each do |provisioner|
+            cfg = provisioner.config
+            path = cfg.upload_path if cfg.respond_to? :upload_path
+            path = cfg.provisioning_path if cfg.respond_to? :provisioning_path
+            @machine.communicate.sudo("chown -R #{username} #{path}",
+              :error_check => false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/actions/set_name.rb

@@ -0,0 +1,53 @@
+require 'vagrant-haipa'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class SetName
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::set_name')
+        end
+
+        def call(env)
+          name = @machine.provider_config.name
+
+          # If we already set the name before, then don't do anything
+          sentinel = @machine.data_dir.join("action_set_name")
+          if !name && sentinel.file?
+            @logger.info("Default name was already set before, not doing it again.")
+            return @app.call(env)
+          end
+
+          # If no name was manually set, then use a default
+          if !name
+            prefix = "#{env[:root_path].basename.to_s}_#{@machine.name}"
+            prefix.gsub!(/[^-a-z0-9_]/i, "")
+
+            # milliseconds + random number suffix to allow for simultaneous
+            # `vagrant up` of the same box in different dirs
+            name = prefix + "_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
+          end
+
+          # Verify the name is not taken
+          haipa_machine = Provider.haipa_machines(@machine).find { |d| d['Name'].to_s == name }
+          raise Vagrant::Errors::VMNameExists, name: name if haipa_machine
+          
+          env[:generated_name] = name
+          # Create the sentinel
+          sentinel.open("w") do |f|
+            f.write(Time.now.to_i.to_s)
+          end
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-haipa/actions/shut_down.rb

@@ -0,0 +1,33 @@
+require 'vagrant-haipa'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class ShutDown
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::shut_down')
+        end
+
+        def call(env)
+          # submit shutdown machine request
+          result = @client.post("/odata/Machines(#{@machine.id})/Stop")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_haipa.info.shutting_down')
+          @client.wait_for_event(env, result['Id'])
+
+          # refresh machine state with provider
+          Provider.haipa_machine(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-haipa/actions/start_machine.rb

@@ -0,0 +1,34 @@
+require 'vagrant-haipa'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class StartMachine
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::power_on')
+        end
+
+        def call(env)
+          # submit power on machine request
+          result = @client.post("/odata/Machines(#{@machine.id})/Start")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_haipa.info.powering_on') 
+          @client.wait_for_event(env, result['Id'])
+
+          # refresh machine state with provider
+          Provider.haipa_machine(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-haipa/actions/stop_machine.rb

@@ -0,0 +1,33 @@
+require 'vagrant-haipa'
+#TODO: --force
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class StopMachine
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::power_off')
+        end
+
+        def call(env)
+          # submit power off machine request
+          result = @client.post("/odata/Machines(#{@machine.id})/Stop")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_haipa.info.powering_off')
+          @client.wait_for_event(env, result['Id'])
+
+          # refresh machine state with provider
+          Provider.haipa_machine(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-haipa/actions/wait_for_ip_address.rb

@@ -0,0 +1,32 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class WaitForIpAddress
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::haipa::wait_for_ip_address')
+        end
+
+        def call(env)
+          # refresh machine state with provider 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
+            addresses.reject! { |s| s.nil? || s.strip.empty? }
+            address = addresses.first
+            raise 'not ready' unless address
+            
+            env[:machine_ip] ||= address
+
+          end          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/config.rb

@@ -0,0 +1,54 @@
+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
+      
+
+      def initialize
+        @token              = UNSET_VALUE
+        @image              = UNSET_VALUE
+        @region             = UNSET_VALUE
+        @flavor             = UNSET_VALUE
+
+        @name               = UNSET_VALUE
+        @vm_config          = UNSET_VALUE
+        @provision          = 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
+      end
+
+      def validate(machine)
+        errors = []
+        #errors << I18n.t('vagrant_haipa.config.token') if !@token
+
+        key = machine.config.ssh.private_key_path
+        key = key[0] if key.is_a?(Array)
+#        if !key
+#          errors << I18n.t('vagrant_haipa.config.private_key')
+#        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+#          errors << I18n.t('vagrant_haipa.config.public_key', {
+#            :key => "#{key}.pub"
+#          })
+       # end
+
+        { 'Haipa Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/errors.rb

@@ -0,0 +1,41 @@
+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      
+    end
+  end
+end