vagrant-openstack-provider 0.1.2 → 0.2.0

data/lib/vagrant-openstack-provider/action/suspend.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Openstack
+    module Action
+      class Suspend
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info I18n.t('vagrant.actions.vm.suspend.suspending')
+            env[:openstack_client].nova.suspend_server(env, env[:machine].id)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-provider/action/sync_folders.rb

@@ -1,46 +1,44 @@
-require "log4r"
+require 'log4r'
 require 'rbconfig'
-require "vagrant/util/subprocess"
+require 'vagrant/util/subprocess'
 
 module VagrantPlugins
   module Openstack
     module Action
-
       class SyncFolders
-        def initialize(app, env)
+        def initialize(app, _env)
           @app = app
         end
 
         def call(env)
           sync_method = env[:machine].provider_config.sync_method
-          if sync_method == "rsync"
+          if sync_method == 'rsync'
             RsyncFolders.new(@app, env).call(env)
-          elsif sync_method == "none"
+          elsif sync_method == 'none'
             NoSyncFolders.new(@app, env).call(env)
           else
-            raise Errors::SyncMethodError, :sync_method_value => sync_method
+            fail Errors::SyncMethodError, sync_method_value: sync_method
           end
         end
-
       end
 
       class NoSyncFolders
-        def initialize(app, env)
+        def initialize(app, _env)
           @app = app
         end
 
         def call(env)
           @app.call(env)
-          env[:ui].info("Sync folders are disabled")
+          env[:ui].info('Sync folders are disabled')
         end
       end
 
       # This middleware uses `rsync` to sync the folders over to the
       # remote instance.
       class RsyncFolders
-        def initialize(app, env)
+        def initialize(app, _env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::sync_folders")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::sync_folders')
           @host_os = RbConfig::CONFIG['host_os']
         end
 
@@ -52,22 +50,20 @@ module VagrantPlugins
           config          = env[:machine].provider_config
           rsync_includes  = config.rsync_includes.to_a
 
-          env[:machine].config.vm.synced_folders.each do |id, data|
+          env[:machine].config.vm.synced_folders.each do |_, data|
             hostpath  = File.expand_path(data[:hostpath], env[:root_path])
             guestpath = data[:guestpath]
 
             # Make sure there is a trailing slash on the host path to
             # avoid creating an additional directory with rsync
             hostpath = "#{hostpath}/" if hostpath !~ /\/$/
-            
+
             # If on Windows, modify the path to work with cygwin rsync
             if @host_os =~ /mswin|mingw|cygwin/
-              hostpath = hostpath.sub(/^([A-Za-z]):\//, "/cygdrive/#{$1.downcase}/")
+              hostpath = hostpath.sub(/^([A-Za-z]):\//, "/cygdrive/#{Regexp.last_match[1].downcase}/")
             end
 
-            env[:ui].info(I18n.t("vagrant_openstack.rsync_folder",
-                                :hostpath => hostpath,
-                                :guestpath => guestpath))
+            env[:ui].info(I18n.t('vagrant_openstack.rsync_folder', hostpath: hostpath, guestpath: guestpath))
 
             # Create the guest path
             env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
@@ -75,46 +71,39 @@ module VagrantPlugins
               "chown -R #{ssh_info[:username]} '#{guestpath}'")
 
             # Generate rsync include commands
-            includes = rsync_includes.each_with_object([]) { |incl, incls| 
-              incls << "--include" 
+            includes = rsync_includes.each_with_object([]) do |incl, incls|
+              incls << '--include'
               incls << incl
-            }
+            end
 
             # Rsync over to the guest path using the SSH info. add
             # .hg/ to exclude list as that isn't covered in
             # --cvs-exclude
             command = [
-              "rsync", "--verbose", "--archive", "-z",
-              "--cvs-exclude", 
-              "--exclude", ".hg/",
+              'rsync', '--verbose', '--archive', '-z',
+              '--cvs-exclude',
+              '--exclude', '.hg/',
               *includes,
-              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_key_options(ssh_info)}",
+              '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_key_options(ssh_info)}",
               hostpath,
               "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
             command.compact!
 
             # during rsync, ignore files specified in .hgignore and
             # .gitignore traditional .gitignore or .hgignore files
-            ignore_files = [".hgignore", ".gitignore"]
+            ignore_files = ['.hgignore', '.gitignore']
             ignore_files.each do |ignore_file|
-              abs_ignore_file = env[:root_path].to_s + "/" + ignore_file
-              if File.exist?(abs_ignore_file)
-                command = command + ["--exclude-from", abs_ignore_file]
-              end
+              abs_ignore_file = env[:root_path].to_s + '/' + ignore_file
+              command += ['--exclude-from', abs_ignore_file] if File.exist?(abs_ignore_file)
             end
 
-            r = Vagrant::Util::Subprocess.execute(*command)
-            if r.exit_code != 0
-              raise Errors::RsyncError,
-                :guestpath => guestpath,
-                :hostpath => hostpath,
-                :stderr => r.stderr
-            end
+            next if Vagrant::Util::Subprocess.execute(*command).exit_code == 0
+            ail Errors::RsyncError, guestpath: guestpath, hostpath: hostpath, stderr: r.stderr
           end
         end
 
         private
- 
+
         def ssh_key_options(ssh_info)
           # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
           Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join

data/lib/vagrant-openstack-provider/action/wait_stop.rb

@@ -0,0 +1,29 @@
+require 'log4r'
+require 'timeout'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class WaitForServerToStop
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::stop_server')
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t('vagrant_openstack.waiting_stop'))
+            client = env[:openstack_client].nova
+            timeout(200) do
+              while client.get_server_details(env, env[:machine].id)['status'] != 'SHUTOFF'
+                sleep 3
+                @logger.debug('Waiting for server to stop')
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-provider/client/keystone.rb

@@ -0,0 +1,76 @@
+require 'log4r'
+require 'restclient'
+require 'json'
+
+module VagrantPlugins
+  module Openstack
+    class KeystoneClient
+      include Singleton
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::keystone')
+        @session = VagrantPlugins::Openstack.session
+      end
+
+      def authenticate(env)
+        @logger.debug('Authenticating on Keystone')
+        config = env[:machine].provider_config
+        env[:ui].info(I18n.t('vagrant_openstack.client.authentication', project: config.tenant_name, user: config.username))
+
+        authentication = RestClient.post(
+            config.openstack_auth_url,
+            {
+              auth:
+              {
+                tenantName: config.tenant_name,
+                passwordCredentials:
+                  {
+                    username: config.username,
+                    password: config.password
+                  }
+              }
+            }.to_json,
+            content_type: :json,
+            accept: :json)
+
+        access = JSON.parse(authentication)['access']
+
+        read_endpoint_catalog(env, access['serviceCatalog'])
+        override_endpoint_catalog_with_user_config(env)
+        print_endpoint_catalog(env)
+
+        response_token = access['token']
+        @session.token = response_token['id']
+        @session.project_id = response_token['tenant']['id']
+      end
+
+      private
+
+      def read_endpoint_catalog(env, catalog)
+        env[:ui].info(I18n.t('vagrant_openstack.client.looking_for_available_endpoints'))
+
+        catalog.each do |service|
+          se = service['endpoints']
+          if se.size > 1
+            env[:ui].warn I18n.t('vagrant_openstack.client.multiple_endpoint', size: se.size, type: service['type'])
+            env[:ui].warn "  => #{service['endpoints'][0]['publicURL']}"
+          end
+          url = se[0]['publicURL'].strip
+          @session.endpoints[service['type'].to_sym] = url unless url.empty?
+        end
+      end
+
+      def override_endpoint_catalog_with_user_config(env)
+        config = env[:machine].provider_config
+        @session.endpoints[:compute] = config.openstack_compute_url unless config.openstack_compute_url.nil?
+        @session.endpoints[:network] = config.openstack_network_url unless config.openstack_network_url.nil?
+      end
+
+      def print_endpoint_catalog(env)
+        @session.endpoints.each do |key, value|
+          env[:ui].info(" -- #{key.to_s.ljust 15}: #{value}")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-provider/client/neutron.rb

@@ -0,0 +1,32 @@
+require 'log4r'
+require 'restclient'
+require 'json'
+
+require 'vagrant-openstack-provider/client/utils'
+
+module VagrantPlugins
+  module Openstack
+    class NeutronClient
+      include Singleton
+      include VagrantPlugins::Openstack::Utils
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::neutron')
+        @session = VagrantPlugins::Openstack.session
+      end
+
+      def get_private_networks(env)
+        authenticated(env) do
+          networks_json = RestClient.get("#{@session.endpoints[:network]}/networks",
+                                         'X-Auth-Token' => @session.token,
+                                         :accept => :json) { |res| handle_response(res) }
+          networks = []
+          JSON.parse(networks_json)['networks'].each do |n|
+            networks << { id: n['id'], name: n['name'] } if n['tenant_id'].eql? @session.project_id
+          end
+          networks
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-provider/client/nova.rb

@@ -0,0 +1,166 @@
+require 'log4r'
+require 'restclient'
+require 'json'
+
+require 'vagrant-openstack-provider/client/utils'
+
+module VagrantPlugins
+  module Openstack
+    class NovaClient
+      include Singleton
+      include VagrantPlugins::Openstack::Utils
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::nova')
+        @session = VagrantPlugins::Openstack.session
+      end
+
+      def get_all_flavors(env)
+        authenticated(env) do
+          flavors_json = RestClient.get("#{@session.endpoints[:compute]}/flavors",
+                                        'X-Auth-Token' => @session.token,
+                                        :accept => :json) { |res| handle_response(res) }
+
+          return JSON.parse(flavors_json)['flavors'].map { |fl| Item.new(fl['id'], fl['name']) }
+        end
+      end
+
+      def get_all_images(env)
+        authenticated(env) do
+          images_json = RestClient.get(
+            "#{@session.endpoints[:compute]}/images",
+            'X-Auth-Token' => @session.token, :accept => :json) { |res| handle_response(res) }
+
+          JSON.parse(images_json)['images'].map { |im| Item.new(im['id'], im['name']) }
+        end
+      end
+
+      def create_server(env, name, image_ref, flavor_ref, networks, keypair)
+        authenticated(env) do
+          server = {}.tap do |s|
+            s['name'] = name
+            s['imageRef'] = image_ref
+            s['flavorRef'] = flavor_ref
+            s['key_name'] = keypair
+            unless networks.nil? || networks.empty?
+              s['networks'] = []
+              networks.each do |uuid|
+                s['networks'] << { uuid: uuid }
+              end
+            end
+          end
+
+          server = RestClient.post(
+            "#{@session.endpoints[:compute]}/servers", { server: server }.to_json,
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+
+          JSON.parse(server)['server']['id']
+        end
+      end
+
+      def delete_server(env, server_id)
+        authenticated(env) do
+          RestClient.delete(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}",
+            'X-Auth-Token' => @session.token,
+            :accept => :json) { |res| handle_response(res) }
+        end
+      end
+
+      def suspend_server(env, server_id)
+        authenticated(env) do
+          RestClient.post(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "suspend": null }',
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+        end
+      end
+
+      def resume_server(env, server_id)
+        # TODO(julienvey) check status before (if pause->unpause, if suspend->resume...)
+        authenticated(env) do
+          RestClient.post(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "resume": null }',
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+        end
+      end
+
+      def stop_server(env, server_id)
+        authenticated(env) do
+          RestClient.post(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "os-stop": null }',
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+        end
+      end
+
+      def start_server(env, server_id)
+        authenticated(env) do
+          RestClient.post(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "os-start": null }',
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+        end
+      end
+
+      def get_server_details(env, server_id)
+        authenticated(env) do
+          server_details = RestClient.get(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}",
+            'X-Auth-Token' => @session.token,
+            :accept => :json) { |res| handle_response(res) }
+
+          return JSON.parse(server_details)['server']
+        end
+      end
+
+      def add_floating_ip(env, server_id, floating_ip)
+        authenticated(env) do
+          check_floating_ip(env, floating_ip)
+          RestClient.post(
+            "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
+            {
+              addFloatingIp:
+              {
+                address: floating_ip
+              }
+            }.to_json,
+            'X-Auth-Token' => @session.token,
+            :accept => :json,
+            :content_type => :json) { |res| handle_response(res) }
+        end
+      end
+
+      private
+
+      def check_floating_ip(_env, floating_ip)
+        ip_details = RestClient.get(
+          "#{@session.endpoints[:compute]}/os-floating-ips",
+          'X-Auth-Token' => @session.token,
+          :accept => :json) { |res| handle_response(res) }
+
+        JSON.parse(ip_details)['floating_ips'].each do |ip|
+          next unless ip['ip'] == floating_ip
+          return if ip['instance_id'].nil?
+          fail "Floating IP #{floating_ip} already assigned to another server"
+        end
+        fail "Floating IP #{floating_ip} not available for this tenant"
+      end
+    end
+
+    class Item
+      attr_accessor :id, :name
+      def initialize(id, name)
+        @id = id
+        @name = name
+      end
+    end
+  end
+end