vagrant-haipa 0.0.1

data/README.md

@@ -0,0 +1,111 @@
+Haipa Vagrant Provider
+=================================
+
+
+`vagrant-haipa` is a Vagrant provider plugin that supports the management of Hyper-V virtual machines with [Haipa](http://www.haipa.io).
+
+Features include:
+- Create and destroy Haipa Machines
+- Power on and off Haipa Machines
+
+
+Install
+-------
+Install the provider plugin using the Vagrant command-line interface:
+
+`vagrant plugin install vagrant-haipa`
+
+
+Configure
+---------
+Once the provider has been installed, you will need to configure your project to use it. See the following example for a basic `Vagrantfile` implementation:
+
+```ruby
+  config.vm.define :ubuntu do |ubuntu|
+    ubuntu.vm.provider :haipa do |provider|
+      provider.vm_config = {
+         'Memory' => {
+          'Startup' => 2048
+        },
+        'Disks' => [
+          {
+            "Template" => 'c:\hyperv-templates\ubuntu-xenial.vhdx',
+            "Size" => 20
+          }
+        ],  
+        'NetworkAdapters' => [
+          {
+            "Name" => "eth0",
+            "SwitchName" => "Default Switch",
+          }                                                          
+        ]
+      }
+    end
+  end
+end
+```
+
+
+**Supported Configuration Attributes**
+
+The following attributes are available to further configure the provider:
+- `provider.vm_config`
+    * A Hash with the Haipa vm configuration
+- `provider.provision`
+    * A Hash with the Haipa provision configuration
+
+Run
+---
+After creating your project's `Vagrantfile` with the required configuration
+attributes described above, you may create a new Machine with the following
+command:
+
+    $ vagrant up --provider=haipa
+
+This command will create a new machine, setup your SSH key for authentication,
+create a new user account, and run the provisioners you have configured.
+
+**Supported Commands**
+
+The provider supports the following Vagrant sub-commands:
+- `vagrant destroy` - Destroys the machine instance.
+- `vagrant ssh` - Logs into the machine instance using the configured user account.
+- `vagrant halt` - Powers off the machine instance.
+- `vagrant provision` - Runs the configured provisioners and rsyncs any specified `config.vm.synced_folder`.
+- `vagrant status` - Outputs the status (active, off, not created) for the machine instance.
+
+
+Troubleshooting
+---------------
+Before submitting a GitHub issue, please ensure both Vagrant and vagrant-haipa are fully up-to-date.
+* For the latest Vagrant version, please visit the [Vagrant](https://www.vagrantup.com/) website
+* To update Vagrant plugins, run the following command: `vagrant plugin update`
+
+
+Contribute
+----------
+To contribute, fork then clone the repository, and then the following:
+
+**Developing**
+
+1. Install [Bundler](http://bundler.io/)
+2. Currently the Bundler version is locked to 1.7.9, please install this version.
+    * `sudo gem install bundler -v '1.7.9'`
+3. Then install vagrant-haipa dependencies:
+    * `bundle _1.7.9_ install`
+4. Do your development and run a few commands, one to get started would be:
+    * `bundle _1.7.9_ exec vagrant haipa-list images`
+5. You can then run a test:
+    * `bundle _1.7.9_ exec rake test`
+6. Once you are satisfied with your changes, please submit a pull request.
+
+**Testing**
+
+1. Build and package your newly developed code:
+    * `rake gem:build`
+2. Then install the packaged plugin:
+    * `vagrant plugin install pkg/vagrant-haipa-*.gem`
+3. Once you're done testing, roll-back to the latest released version:
+    * `vagrant plugin uninstall vagrant-haipa`
+    * `vagrant plugin install vagrant-haipa`
+4. Once you're satisfied developing and testing your new code, please submit a pull request for review.

data/Rakefile

@@ -0,0 +1,24 @@
+require "rubygems"
+require "bundler/setup"
+
+
+namespace :gem do
+  Bundler::GemHelper.install_tasks
+end
+
+task :test do
+  result = sh 'bash test/test.sh'
+
+  if result
+    puts 'Success!'
+  else
+    puts 'Failure!'
+    exit 1
+  end
+end
+
+def env
+  ['DO_CLIENT_ID', 'DO_API_KEY', 'VAGRANT_LOG'].inject('') do |acc, key|
+    acc += "#{key}=#{ENV[key] || 'error'} "
+  end
+end

data/box/metadata.json

@@ -0,0 +1,3 @@
+{
+  "provider": "haipa"
+}

data/lib/vagrant-haipa.rb

@@ -0,0 +1,20 @@
+require 'vagrant-haipa/version'
+require 'vagrant-haipa/plugin'
+require 'vagrant-haipa/errors'
+
+module VagrantPlugins
+  module Haipa
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+
+    def self.public_key(private_key_path)
+      File.read("#{private_key_path}.pub") 
+    rescue
+      raise Errors::PublicKeyError, :path => "#{private_key_path}.pub"
+    end
+
+    I18n.load_path << File.expand_path('locales/en.yml', source_root)
+    I18n.reload!
+  end
+end

data/lib/vagrant-haipa/actions.rb

@@ -0,0 +1,209 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      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|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectHaipa
+            b2.use StopMachine
+          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
+              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
+            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|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncedFolderCleanup
+            b2.use SyncedFolders
+          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 ConnectHaipa
+          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 ConnectHaipa
+          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|
+            unless 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|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_ssh_ip
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, ConfigValidate do |env, b2|
+            b2.use WaitForIpAddress
+          end
+        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
+        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
+                end
+              end
+            else
+              b1.use SetName
+              b1.use CreateMachine
+              b1.use action_start
+            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
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path('../actions', __FILE__))
+      autoload :ConnectHaipa, action_root.join('connect_haipa')
+      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 :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

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class CheckState
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::haipa::check_state')
+        end
+
+        def call(env)
+          env[:machine_state] = @machine.state.id
+          @logger.info "Machine state is '#{@machine.state.id}'"
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'vagrant-haipa'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class ConnectHaipa
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::ConnectHaipa')
+        end
+
+        def call(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,56 @@
+require 'vagrant-haipa/helpers/client'
+
+module VagrantPlugins
+  module Haipa
+    module Actions
+      class CreateMachine
+        include Helpers::Client
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::haipa::create_machine')
+        end
+
+        def call(env)
+          ssh_key_id = [env[:ssh_key_id]]
+
+          # submit new machine request
+          result = @client.post('/odata/Machines', {
+
+                  'Name' => env[:generated_name],                           
+                  'VM' => @machine.provider_config.vm_config,
+                  "Provisioning" => @machine.provider_config.provision            
+        })
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_haipa.info.creating')
+          @client.wait_for_event(env, result['Id'])
+
+          # assign the machine id for reference in other commands
+          operation_result = @client.request("odata/Operations(#{result['Id']})")
+          @machine.id = operation_result['MachineGuid'].to_s
+
+          @app.call(env)
+        end
+
+        # Both the recover and terminate are stolen almost verbatim from
+        # the Vagrant AWS provider up action
+        def recover(env)
+          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
+          terminate(env) if @machine.state.id != :not_created
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Actions.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end