vagrant-haipa 0.0.1

data/lib/vagrant-haipa/helpers/client.rb

@@ -0,0 +1,111 @@
+require 'vagrant-haipa/helpers/result'
+require 'faraday'
+require 'json'
+module VagrantPlugins
+  module Haipa
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine)
+        end
+      end
+
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        def initialize(machine)
+          @logger = Log4r::Logger.new('vagrant::haipa::apiclient')
+          @config = machine.provider_config
+          @client = Faraday.new({
+            :url => 'http://localhost:62189/',
+            :ssl => {
+              :ca_file => @config.ca_path
+            }
+          })
+        end
+
+        def delete(path, params = {})
+          request(path, params, :delete)
+        end
+
+        def post(path, params = {})
+          @client.headers['Content-Type'] = 'application/json'
+          request(path, params, :post)
+        end
+
+        def request(path, params = {}, method = :get)
+          begin
+            @logger.info "Request: #{path}"
+            result = @client.send(method) do |req|
+              req.url path
+              req.body = params.to_json unless method == :get
+              req.params = params if method == :get
+
+              req.headers['Authorization'] = "Bearer #{@config.token}"
+            end
+          rescue Faraday::Error::ConnectionFailed => e
+            # TODO this is suspect but because farady wraps the exception
+            #      in something generic there doesn't appear to be another
+            #      way to distinguish different connection errors :(
+            if e.message =~ /certificate verify failed/
+              raise Errors::CertificateError
+            end
+
+            raise e
+          end
+
+          begin
+            body = JSON.parse(result.body)
+            body.delete_if { |key, _| key == '@odata.context' }
+
+            @logger.info "Response: #{body}"
+          rescue JSON::ParserError => e
+            raise(Errors::JSONError, {
+              :message => e.message,
+              :path => path,
+              :params => params,
+              :response => result.body
+            })
+          end
+
+          unless /^2\d\d$/ =~ result.status.to_s
+            raise(Errors::APIStatusError, {
+              :path => path,
+              :params => params,
+              :status => result.status,
+              :response => body.inspect
+            })
+          end
+          Result.new(body)
+        end
+
+        def wait_for_event(env, id)
+          timestamp = '2018-09-01T23:47:17.50094+02:00'
+
+          operation_error = nil
+          retryable(:tries => 20, :sleep => 5) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+
+            # check action status
+            result = request("odata/Operations(#{id})", '$expand' => "LogEntries($filter=Timestamp gt #{timestamp})")
+
+            result['LogEntries'].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['Status'] == 'Queued'
+            operation_error = result['StatusMessage'] if result['Status'] == 'Failed'
+          end
+
+          raise "Operation failed: #{operation_error}" if operation_error
+
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/helpers/result.rb

@@ -0,0 +1,40 @@
+module VagrantPlugins
+  module Haipa
+    module Helpers
+      class Result
+        def initialize(body)
+          @result = body
+        end
+
+        def [](key)
+          @result[key.to_s]
+        end
+
+        def find_id(sub_obj, search) #:ssh_keys, {:name => 'ijin (vagrant)'}
+          find(sub_obj, search)['id']
+        end
+
+        def find(sub_obj, search)
+          key = search.keys.first #:slug
+          value = search[key].to_s #sfo1
+          key = key.to_s #slug
+
+          result = @result[sub_obj.to_s].inject(nil) do |result2, obj|
+            obj[key] == value ? obj : result2
+          end
+
+          result || error(sub_obj, key, value)
+        end
+
+        def error(sub_obj, key, value)
+          raise(Errors::ResultMatchError, {
+           :key => key,
+           :value => value,
+           :collection_name => sub_obj.to_s,
+           :sub_obj => @result[sub_obj.to_s]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/plugin.rb

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

data/lib/vagrant-haipa/provider.rb

@@ -0,0 +1,118 @@
+require 'vagrant-haipa/actions'
+require 'vagrant-haipa/helpers/client'
+
+module VagrantPlugins
+  module Haipa
+    class Provider < Vagrant.plugin('2', :provider)
+
+      def self.haipa_machines(machine)
+        client = Helpers::ApiClient.new(machine)
+
+        unless @haipa_machines
+          result = client.request('/odata/Machines', {'$expand' => 'Networks' })
+          @haipa_machines = result['value']
+        end
+        return @haipa_machines
+      end
+
+      # This class method caches status for all machines within
+      # the Haipa account. A specific machine's status
+      # may be refreshed by passing :refresh => true as an option.
+      def self.haipa_machine(machine, opts = {})
+        client = Helpers::ApiClient.new(machine)
+
+        # load status of machines if it has not been done before
+        haipa_machines(machine)
+
+        if opts[:refresh] && machine.id
+          # refresh the machine status for the given machine
+          @haipa_machines.delete_if { |d| d['Id'].to_s == machine.id }
+          result = client.request("/odata/Machines(#{machine.id})", {'$expand' => 'Networks' })
+          @haipa_machines << haipa_machine = result
+        else
+          # lookup machine status for the given machine
+          haipa_machine = @haipa_machines.find { |d| d['Id'].to_s == machine.id }
+        end
+
+        # if lookup by id failed, check for a machine with a matching name
+        # and set the id to ensure vagrant stores locally
+        # TODO allow the user to configure this behavior
+        unless haipa_machine
+          name = machine.config.vm.hostname || machine.name
+          haipa_machine = @haipa_machines.find { |d| d['Name'] == name.to_s }
+          machine.id = haipa_machine['Id'].to_s if haipa_machine
+        end
+
+        haipa_machine || { 'Status' => 'not_created' }
+      end
+
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Actions.send(action_method) if Actions.respond_to?(action_method)
+        nil
+      end
+
+      # This method is called if the underying machine ID changes. Providers
+      # can use this method to load in new data for the actual backing
+      # machine or to realize that the machine is now gone (the ID can
+      # become `nil`). No parameters are given, since the underlying machine
+      # is simply the machine instance given to this object. And no
+      # return value is necessary.
+      def machine_id_changed
+      end
+
+      # This should return a hash of information that explains how to
+      # SSH into the machine. If the machine is not at a point where
+      # SSH is even possible, then `nil` should be returned.
+      #
+      # The general structure of this returned hash should be the
+      # following:
+      #
+      #     {
+      #       :host => "1.2.3.4",
+      #       :port => "22",
+      #       :username => "mitchellh",
+      #       :private_key_path => "/path/to/my/key"
+      #     }
+      #
+      # **Note:** Vagrant only supports private key based authenticatonion,
+      # mainly for the reason that there is no easy way to exec into an
+      # `ssh` prompt with a password, whereas we can pass a private key
+      # via commandline.
+      def ssh_info
+        machine = Provider.haipa_machine(@machine)
+
+        return nil if machine['Status'].to_sym != :Running
+
+
+        # Run a custom action called "ssh_ip" which does what it says and puts
+        # the IP found into the `:machine_ip` key in the environment.
+        env = @machine.action("ssh_ip")
+
+        # If we were not able to identify the machine IP, we return nil
+        # here and we let Vagrant core deal with it ;)
+        return nil unless env[:machine_ip]
+
+       return {
+           :host => env[:machine_ip],
+        }
+      end
+
+      # This should return the state of the machine within this provider.
+      # The state must be an instance of {MachineState}. Please read the
+      # documentation of that class for more information.
+      def state
+        state = Provider.haipa_machine(@machine)['Status'].downcase.to_sym
+        long = short = state.to_s
+        Vagrant::MachineState.new(state, short, long)
+      end
+    end
+  end
+end

data/lib/vagrant-haipa/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Haipa
+    VERSION = '0.0.1'
+  end
+end

data/locales/en.yml

@@ -0,0 +1,95 @@
+en:
+  vagrant_haipa:
+    info:
+      off: "Machine is off"
+      not_created: "Machine has not been created"
+      already_active: "Machine is already active"
+      already_off: "Machine is already off"
+      creating: "Creating a new machine..."
+      machine_ip: "Assigned IP address: %{ip}"
+      destroying: "Destroying the machine..."
+      shutting_down: "Shutting down the machine..."
+      powering_off: "Powering off the machine..."
+      powering_on: "Powering on the machine..."
+      rebuilding: "Rebuilding the machine..."
+      reloading: "Rebooting the machine..."
+      creating_user: "Creating user account: %{user}..."
+      late_sudo_install_deb8:  "Haipa's debian-8 image lacks sudo. Installing now."
+      modifying_sudo: "Modifying sudoers file to remove tty requirement..."
+      using_key: "Using existing SSH key: %{name}"
+      creating_key: "Creating new SSH key: %{name}..."
+      trying_rsync_install: "Rsync not found, attempting to install with yum..."
+      rsyncing: "Rsyncing folder: %{hostpath} => %{guestpath}..."
+      rsync_missing: "The rsync executable was not found in the current path."
+      images: "Description                                        Slug                           ID\n\n%{images}"
+      images_with_regions: "Description                                        Slug                 ID                 Regions\n\n%{images}"
+      regions: "Description                    Slug\n\n%{regions}"
+      sizes: "Memory          CPUs            Slug\n\n%{sizes}"
+      list_error: 'Could not contact the Haipa API: %{message}'
+      will_not_destroy: |-
+        The instance '%{name}' will not be destroyed, since the confirmation
+        was declined.      
+      already_status: |-
+        The machine is already %{status}.        
+    config:
+      token: "Token is required"
+      private_key: "SSH private key path is required"
+      public_key: "SSH public key not found: %{key}"
+    errors:
+      public_key: |-
+        There was an issue reading the public key at:
+
+        Path: %{path}
+
+        Please check the file's permissions.
+      api_status: |-
+        There was an issue with the request made to the Haipa
+        API at:
+
+        Path: %{path}
+        URI Params: %{params}
+
+        The response status from the API was:
+
+        Status: %{status}
+        Response: %{response}
+      rsync: |-
+        There was an error when attemping to rsync a share folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+      json: |-
+        There was an issue with the JSON response from the Haipa
+        API at:
+
+        Path: %{path}
+        URI Params: %{params}
+
+        The response JSON from the API was:
+
+        Response: %{response}
+      result_match: |-
+        The result collection for %{collection_name}:
+
+        %{sub_obj}
+
+        Contained no object with the value "%{value}" for the the
+        key "%{key}".
+
+        Please ensure that the configured value exists in the collection.
+      certificate: |-
+        The secure connection to the Haipa API has failed. Please
+        ensure that your local certificates directory is defined in the
+        provider config.
+
+            config.vm.provider :haipa do |vm|
+              vm.ca_path = "/path/to/ssl/ca/cert.crt"
+            end
+
+        This is generally caused by the OpenSSL configuration associated
+        with the Ruby install being unaware of the system specific ca
+        certs.
+      local_ip: |-
+        The Haipa provider was unable to determine the host's IP.

data/test/Vagrantfile

@@ -0,0 +1,43 @@
+REQUIRED_PLUGINS = %w(vagrant-haipa)
+
+Vagrant.configure('2') do |config|
+
+  config.ssh.username = 'ubuntu'
+  config.ssh.password = 'vagrant'
+
+  config.vm.synced_folder ".", "/vagrant", disabled: true
+ 
+  #config.vm.provision :shell, :path => 'scripts/provision.sh'
+
+  config.vm.define :ubuntu do |ubuntu|
+    ubuntu.vm.provider :haipa do |provider|
+      provider.vm_config = {
+         'Memory' => {
+          'Startup' => 2048
+        },
+        'Disks' => [
+          {
+            "Template" => 'T:\openstack\ubuntu-xenial.vhdx',
+            "Size" => 20
+          }
+        ],  
+        'NetworkAdapters' => [
+          {
+            "Name" => "eth0",
+            "SwitchName" => "Default Switch",
+          }                                                          
+        ] ,
+      }
+
+      provider.provision = {
+        'Hostname' => 'basic',
+        "UserData" => {
+          "password" => config.ssh.password,
+          "chpasswd" => {
+            "expire"=> "False"
+        }
+      }
+    }
+    end
+  end
+end

data/test/cookbooks/test/recipes/default.rb

@@ -0,0 +1 @@
+log 'Testing 1 2 3!'