vagrant-conoha 0.1.0

data/lib/vagrant-conoha/client/glance.rb

@@ -0,0 +1,65 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/http_utils'
+require 'vagrant-conoha/client/rest_utils'
+require 'vagrant-conoha/client/domain'
+
+module VagrantPlugins
+  module ConoHa
+    class GlanceClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils
+      include VagrantPlugins::ConoHa::Domain
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::glance')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def get_api_version_list(env)
+        json = RestUtils.get(env, @session.endpoints[:image],
+                             'X-Auth-Token' => @session.token,
+                             :accept => :json) do |response|
+          log_response(response)
+          case response.code
+          when 200, 300
+            response
+          when 401
+            fail Errors::AuthenticationFailed
+          else
+            fail Errors::VagrantOpenstackError, message: response.to_s
+          end
+        end
+        JSON.parse(json)['versions']
+      end
+
+      # Endpoint /images exists on both v1 and v2 API
+      # The attribute 'visibility' is used to detect
+      # if the call has been made on v1 or v2
+      #
+      # In case of v2 we have all the needed information,
+      # but in case of v1 we don't and we have to call
+      # /images/detail to get full details
+      #
+      def get_all_images(env)
+        images_json = get(env, "#{@session.endpoints[:image]}/images")
+        images = JSON.parse(images_json)['images']
+
+        return images if images.empty?
+
+        is_v1 = false
+        unless images[0].key? 'visibility'
+          is_v1 = true
+          images_json = get(env, "#{@session.endpoints[:image]}/images/detail")
+          images = JSON.parse(images_json)['images']
+        end
+
+        images.map do |i|
+          i['visibility'] = i['is_public'] ? 'public' : 'private' if is_v1
+          Image.new(i['id'], i['name'], i['visibility'], i['size'], i['min_ram'], i['min_disk'])
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/heat.rb

@@ -0,0 +1,49 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/http_utils'
+require 'vagrant-conoha/client/domain'
+
+module VagrantPlugins
+  module ConoHa
+    class HeatClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils
+      include VagrantPlugins::ConoHa::Domain
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::glance')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def create_stack(env, options)
+        stack = {}.tap do |s|
+          s['stack_name'] = options[:name] if options[:name]
+          s['template'] = options[:template]
+        end
+        stack_res = post(env, "#{@session.endpoints[:orchestration]}/stacks", stack.to_json)
+        JSON.parse(stack_res)['stack']['id']
+      end
+
+      def get_stack_details(env, stack_name, stack_id)
+        stack_exists do
+          server_details = get(env, "#{@session.endpoints[:orchestration]}/stacks/#{stack_name}/#{stack_id}")
+          JSON.parse(server_details)['stack']
+        end
+      end
+
+      def delete_stack(env, stack_name, stack_id)
+        stack_exists do
+          delete(env, "#{@session.endpoints[:orchestration]}/stacks/#{stack_name}/#{stack_id}")
+        end
+      end
+
+      def stack_exists
+        return yield
+      rescue Errors::VagrantOpenstackError => e
+        raise Errors::StackNotFound if e.extra_data[:code] == 404
+        raise e
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/http_utils.rb

@@ -0,0 +1,116 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/keystone'
+require 'vagrant-conoha/client/request_logger'
+require 'vagrant-conoha/client/rest_utils'
+
+module VagrantPlugins
+  module ConoHa
+    module HttpUtils
+      include VagrantPlugins::ConoHa::HttpUtils::RequestLogger
+
+      def get(env, url, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json)
+
+        log_request(:GET, url, headers)
+
+        authenticated(env) do
+          RestUtils.get(env, url, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      def post(env, url, body = nil, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json, :content_type => :json)
+
+        log_request(:POST, url, body, headers)
+
+        authenticated(env) do
+          RestUtils.post(env, url, body, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      def delete(env, url, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json, :content_type => :json)
+
+        log_request(:DELETE, url, headers)
+
+        authenticated(env) do
+          RestUtils.delete(env, url, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      def get_api_version_list(env, service_type)
+        url = @session.endpoints[service_type]
+        headers = { 'X-Auth-Token' => @session.token, :accept => :json }
+        log_request(:GET, url, headers)
+
+        json = RestUtils.get(env, url, headers) do |response|
+          log_response(response)
+          case response.code
+          when 200, 300
+            response
+          when 401
+            fail Errors::AuthenticationFailed
+          else
+            fail Errors::VagrantOpenstackError, message: response.to_s
+          end
+        end
+        JSON.parse(json)['versions']
+      end
+
+      private
+
+      ERRORS =
+          {
+            '400' => 'badRequest',
+            '404' => 'itemNotFound',
+            '409' => 'conflictingRequest'
+          }
+
+      def handle_response(response)
+        log_response(response)
+        case response.code
+        when 200, 201, 202, 204
+          response
+        when 401
+          fail Errors::AuthenticationRequired
+        when 400, 404, 409
+          message = JSON.parse(response.to_s)[ERRORS[response.code.to_s]]['message']
+          fail Errors::VagrantOpenstackError, message: message, code: response.code
+        else
+          fail Errors::VagrantOpenstackError, message: response.to_s, code: response.code
+        end
+      end
+
+      def authenticated(env)
+        nb_retry = 0
+        begin
+          return yield
+        rescue Errors::AuthenticationRequired => e
+          nb_retry += 1
+          env[:ui].warn(e)
+          env[:ui].warn(I18n.t('vagrant_openstack.trying_authentication'))
+          env[:openstack_client].keystone.authenticate(env)
+          retry if nb_retry < 3
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/keystone.rb

@@ -0,0 +1,77 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/request_logger'
+
+module VagrantPlugins
+  module ConoHa
+    class KeystoneClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils::RequestLogger
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::keystone')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def authenticate(env)
+        @logger.info('Authenticating on Keystone')
+        config = env[:machine].provider_config
+        @logger.info(I18n.t('vagrant_openstack.client.authentication', project: config.tenant_name, user: config.username))
+
+        post_body =
+          {
+            auth:
+              {
+                tenantName: config.tenant_name,
+                passwordCredentials:
+                  {
+                    username: config.username,
+                    password: '****'
+                  }
+              }
+          }
+
+        auth_url = get_auth_url_v2 env
+
+        headers = {
+          content_type: :json,
+          accept: :json
+        }
+
+        log_request(:POST, auth_url, post_body.to_json, headers)
+
+        post_body[:auth][:passwordCredentials][:password] = config.password
+
+        authentication = RestUtils.post(env, auth_url, post_body.to_json, headers) do |response|
+          log_response(response)
+          case response.code
+          when 200
+            response
+          when 401
+            fail Errors::AuthenticationFailed
+          when 404
+            fail Errors::BadAuthenticationEndpoint
+          else
+            fail Errors::VagrantOpenstackError, message: response.to_s
+          end
+        end
+
+        access = JSON.parse(authentication)['access']
+        response_token = access['token']
+        @session.token = response_token['id']
+        @session.project_id = response_token['tenant']['id']
+
+        access['serviceCatalog']
+      end
+
+      private
+
+      def get_auth_url_v2(env)
+        url = env[:machine].provider_config.openstack_auth_url
+        return url if url.match(%r{/tokens/*$})
+        "#{url}/tokens"
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/neutron.rb

@@ -0,0 +1,48 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/http_utils'
+require 'vagrant-conoha/client/domain'
+
+module VagrantPlugins
+  module ConoHa
+    class NeutronClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils
+      include VagrantPlugins::ConoHa::Domain
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::neutron')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def get_private_networks(env)
+        get_networks(env, false)
+      end
+
+      def get_all_networks(env)
+        get_networks(env, true)
+      end
+
+      def get_subnets(env)
+        subnets_json = get(env, "#{@session.endpoints[:network]}/subnets")
+        subnets = []
+        JSON.parse(subnets_json)['subnets'].each do |n|
+          subnets << Subnet.new(n['id'], n['name'], n['cidr'], n['enable_dhcp'], n['network_id'])
+        end
+        subnets
+      end
+
+      private
+
+      def get_networks(env, all)
+        networks_json = get(env, "#{@session.endpoints[:network]}/networks")
+        networks = []
+        JSON.parse(networks_json)['networks'].each do |n|
+          networks << Item.new(n['id'], n['name']) if all || n['tenant_id'].eql?(@session.project_id)
+        end
+        networks
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/nova.rb

@@ -0,0 +1,212 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/http_utils'
+require 'vagrant-conoha/client/domain'
+
+module VagrantPlugins
+  module ConoHa
+    class NovaClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils
+      include VagrantPlugins::ConoHa::Domain
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::nova')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def get_all_flavors(env)
+        flavors_json = get(env, "#{@session.endpoints[:compute]}/flavors/detail")
+        JSON.parse(flavors_json)['flavors'].map do |fl|
+          Flavor.new(fl['id'], fl['name'], fl['vcpus'], fl['ram'], fl['disk'])
+        end
+      end
+
+      def get_all_floating_ips(env)
+        ips_json = get(env, "#{@session.endpoints[:compute]}/os-floating-ips",
+                       'X-Auth-Token' => @session.token,
+                       :accept => :json)
+        JSON.parse(ips_json)['floating_ips'].map { |n| FloatingIP.new(n['ip'], n['pool'], n['instance_id']) }
+      end
+
+      def allocate_floating_ip(env, pool)
+        ips_json = post(env, "#{@session.endpoints[:compute]}/os-floating-ips",
+                        {
+                          pool: pool
+                        }.to_json,
+                        'X-Auth-Token' => @session.token,
+                        :accept => :json,
+                        :content_type => :json)
+        floating_ip = JSON.parse(ips_json)['floating_ip']
+        FloatingIP.new(floating_ip['ip'], floating_ip['pool'], floating_ip['instance_id'])
+      end
+
+      def get_all_images(env)
+        images_json = get(env, "#{@session.endpoints[:compute]}/images")
+        JSON.parse(images_json)['images'].map { |fl| Image.new(fl['id'], fl['name'], 'unknown') }
+      end
+
+      def create_server(env, options)
+        server = {}.tap do |s|
+          s['name'] = options[:name]
+          if options[:image_ref].nil?
+            s['block_device_mapping'] = [{ volume_id: options[:volume_boot][:id],
+                                           device_name: options[:volume_boot][:device] }] if options[:volume_boot].key?(:id)
+            s['block_device_mapping_v2'] = [{ boot_index: '0',
+                                              volume_size: options[:volume_boot][:size],
+                                              uuid: options[:volume_boot][:image],
+                                              device_name: options[:volume_boot][:device],
+                                              source_type: 'image',
+                                              destination_type: 'volume',
+                                              delete_on_termination: options[:volume_boot][:delete_on_destroy] }]\
+                                              if options[:volume_boot].key?(:image)
+          else
+            s['imageRef'] = options[:image_ref]
+          end
+          s['flavorRef'] = options[:flavor_ref]
+          s['key_name'] = options[:keypair]
+          s['availability_zone'] = options[:availability_zone] unless options[:availability_zone].nil?
+          s['security_groups'] = options[:security_groups] unless options[:security_groups].nil?
+          s['user_data'] = Base64.encode64(options[:user_data]) unless options[:user_data].nil?
+          s['metadata'] = options[:metadata] unless options[:metadata].nil?
+          s['networks'] = options[:networks] unless options[:networks].nil? || options[:networks].empty?
+        end
+        object = { server: server }
+        object['os:scheduler_hints'] = options[:scheduler_hints] unless options[:scheduler_hints].nil?
+        server = post(env, "#{@session.endpoints[:compute]}/servers", object.to_json)
+        JSON.parse(server)['server']['id']
+      end
+
+      def delete_server(env, server_id)
+        instance_exists do
+          delete(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+        end
+      end
+
+      def suspend_server(env, server_id)
+        instance_exists do
+          change_server_state(env, server_id, :suspend)
+        end
+      end
+
+      def resume_server(env, server_id)
+        instance_exists do
+          change_server_state(env, server_id, :resume)
+        end
+      end
+
+      def stop_server(env, server_id)
+        instance_exists do
+          change_server_state(env, server_id, :stop)
+        end
+      end
+
+      def start_server(env, server_id)
+        instance_exists do
+          change_server_state(env, server_id, :start)
+        end
+      end
+
+      def get_server_details(env, server_id)
+        instance_exists do
+          server_details = get(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+          JSON.parse(server_details)['server']
+        end
+      end
+
+      def add_floating_ip(env, server_id, floating_ip)
+        instance_exists do
+          check_floating_ip(env, floating_ip)
+
+          post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
+               { addFloatingIp: { address: floating_ip } }.to_json)
+        end
+      end
+
+      def import_keypair(env, public_key)
+        keyname = "vagrant-generated-#{Kernel.rand(36**8).to_s(36)}"
+
+        key_details = post(env, "#{@session.endpoints[:compute]}/os-keypairs",
+                           { keypair:
+                             {
+                               name: keyname,
+                               public_key: public_key
+                             }
+                           }.to_json)
+        JSON.parse(key_details)['keypair']['name']
+      end
+
+      def import_keypair_from_file(env, public_key_path)
+        fail "File specified in public_key_path #{public_key_path} doesn't exist" unless File.exist?(public_key_path)
+        file = File.open(public_key_path)
+        import_keypair(env, file.read)
+      end
+
+      def delete_keypair_if_vagrant(env, server_id)
+        instance_exists do
+          keyname = get_server_details(env, server_id)['key_name']
+          if keyname
+            delete(env, "#{@session.endpoints[:compute]}/os-keypairs/#{keyname}") if keyname.start_with?('vagrant-generated-')
+          end
+        end
+      end
+
+      def get_floating_ip_pools(env)
+        floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ip-pools")
+        JSON.parse(floating_ips)['floating_ip_pools']
+      end
+
+      def get_floating_ips(env)
+        floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ips")
+        JSON.parse(floating_ips)['floating_ips']
+      end
+
+      def attach_volume(env, server_id, volume_id, device = nil)
+        instance_exists do
+          attachment = post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/os-volume_attachments",
+                            {
+                              volumeAttachment: {
+                                volumeId: volume_id,
+                                device: device
+                              }
+                            }.to_json)
+          JSON.parse(attachment)['volumeAttachment']
+        end
+      end
+
+      private
+
+      VM_STATES =
+          {
+            suspend: 'suspend',
+            resume: 'resume',
+            start: 'os-start',
+            stop: 'os-stop'
+          }
+
+      def instance_exists
+        return yield
+      rescue Errors::VagrantOpenstackError => e
+        raise Errors::InstanceNotFound if e.extra_data[:code] == 404
+        raise e
+      end
+
+      def change_server_state(env, server_id, new_state)
+        post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
+             { :"#{VM_STATES[new_state.to_sym]}" => nil }.to_json)
+      end
+
+      def check_floating_ip(env, floating_ip)
+        ip_details = get(env, "#{@session.endpoints[:compute]}/os-floating-ips")
+
+        JSON.parse(ip_details)['floating_ips'].each do |ip|
+          next unless ip['ip'] == floating_ip
+          return if ip['instance_id'].nil?
+          fail Errors::FloatingIPAlreadyAssigned, floating_ip: floating_ip
+        end
+        fail Errors::FloatingIPNotAvailable, floating_ip: floating_ip
+      end
+    end
+  end
+end