misty 0.1.0 → 0.3.0

data/lib/misty/cloud.rb

@@ -0,0 +1,133 @@
+require 'misty/auth/auth_v2'
+require 'misty/auth/auth_v3'
+
+module Misty
+  class Cloud
+    Setup   = Struct.new(:auth, :content_type, :log)
+
+    Options = Struct.new(:alarming, :baremetal, :block_storage, :clustering, :compute, :container, :data_processing,
+      :database, :data_protection, :dns, :identity, :image, :messaging, :metering, :network, :object_storage,
+      :orchestration, :search, :shared_file_systems)
+
+    attr_reader :services
+
+    def initialize(options = {:auth => {}})
+      @cloud = Setup.new
+      @cloud.auth = Misty::Auth.factory(options[:auth])
+      @cloud.content_type = options[:content_type] ? options[:content_type] : nil
+      @cloud.log = Logger.new(options[:log_file] ? options[:log_file] : Misty::LOG_FILE)
+      @cloud.log.level = options[:log_level] ? options[:log_level] : Misty::LOG_LEVEL
+
+      @options = Options.new
+      Misty.services.each do |service|
+        @options.send("#{service.name}=".to_sym, options[service.name] ? options[service.name] : {})
+      end
+
+      @services = setup_services(@options)
+    end
+
+    def setup_services(options)
+      services = {}
+      Misty.services.each do |service|
+        if options[service.name] && options[service.name][:api_version] \
+          && service.versions.include?(options[service.name][:api_version])
+          services.merge!(service.name => {service.project => options[service.name][:api_version]})
+        else
+          # Highest version is used by default!
+          services.merge!(service.name => {service.project => service.versions.sort[-1]})
+        end
+      end
+      services
+    end
+
+    def build_service(service_name)
+      project = @services[service_name].keys[0]
+      version = @services[service_name].fetch(project)
+      version = self.class.dot_to_underscore(version)
+      klass = Object.const_get("Misty::Openstack::#{project.capitalize}::#{version.capitalize}")
+      klass.new(@cloud, @options[service_name])
+    end
+
+    def self.dot_to_underscore(val)
+      val.gsub(/\./,'_')
+    end
+
+    def alarming
+      @alarming ||= build_service(:alarming)
+    end
+
+    def baremetal
+      @baremetal ||= build_service(:baremetal)
+    end
+
+    def block_storage
+      @block_storage ||= build_service(:block_storage)
+    end
+
+    alias volume block_storage
+
+    def clustering
+      @clustering ||= build_service(:clustering)
+    end
+
+    def compute
+      @compute ||= build_service(:compute)
+    end
+
+    def container
+      @container ||= build_service(:container)
+    end
+
+    def data_processing
+      @data_processing ||= build_service(:data_processing)
+    end
+
+    def data_protection
+      @data_protection ||= build_service(:data_protection)
+    end
+
+    def database
+      @database ||= build_service(:database)
+    end
+
+    def dns
+      @dns ||= build_service(:dns)
+    end
+
+    def identity
+      @identity ||= build_service(:identity)
+    end
+
+    def image
+      @image ||= build_service(:image)
+    end
+
+    def messaging
+      @messaging ||= build_service(:messaging)
+    end
+
+    def metering
+      @metering ||= build_service(:metering)
+    end
+
+    def network
+      @network ||= build_service(:network)
+    end
+
+    def object_storage
+      @object_storage ||= build_service(:object_storage)
+    end
+
+    def orchestration
+      @orchestration ||= build_service(:orchestration)
+    end
+
+    def search
+      @search ||= build_service(:search)
+    end
+
+    def shared_file_systems
+      @shared_file_systems ||= build_service(:shared_file_systems)
+    end
+  end
+end

data/lib/misty/http/client.rb

@@ -0,0 +1,115 @@
+require 'misty/http/method_builder'
+require 'misty/http/request'
+require 'misty/http/direct'
+
+module Misty
+  module HTTP
+    class Client
+      class InvalidDataError < StandardError; end
+
+      include Misty::HTTP::MethodBuilder
+      include Misty::HTTP::Request
+      include Misty::HTTP::Direct
+
+      INTERFACES = %w{admin public internal}
+
+      attr_reader :microversion
+
+      Options = Struct.new(:base_path, :base_url, :interface, :region_id, :service_names, :ssl_verify_mode, :version)
+
+      def requests
+        list = []
+        self.class.api.each do |_path, verbs|
+          verbs.each do |_verb, requests|
+            list << requests
+          end
+        end
+        list.flatten.sort
+      end
+
+      # Options - Values shown are the default
+      #   Base path can be forced (Not recommended, mainly used for test purposes)
+      #    :base_path => nil
+      #   URL can be forced (Helps when setup is broken)
+      #    :base_url => nil
+      #   Endpoint type (admin, public or internal)
+      #     :interface => "public"
+      #   Region ID
+      #    :region_id => "regionOne"
+      #   Service name
+      #    The Service names are pre defined but more can be added using this option.
+      #    :service_name
+      #   SSL Verify Mode
+      #     :ssl_verify_mode => true
+      #   (micro)version: Can be numbered (3.1) or by state (CURRENT, LATEST or SUPPORTED)
+      #     :version => "CURRENT"
+      def initialize(cloud, options)
+        @cloud = cloud
+        @options = setup(options)
+        @uri = URI.parse(@cloud.auth.get_endpoint(@options.service_names, @options.region_id, @options.interface))
+        @base_path = @options.base_path ? @options.base_path : @uri.path
+        @base_path = @base_path.chomp("/")
+        @http = net_http(@uri)
+        @version = nil
+        @microversion = false
+      end
+
+      # Sub classes to override
+      # When a catalog provides a base path and the Service API definition containts the generic equivalent as prefix
+      # then the preifx is redundant and must be removed from the path.
+      # For example:
+      # Catalog provides "http://192.0.2.21:8004/v1/48985e6b8da145699d411f12a3459fca"
+      # and Service API has "/v1/{tenant_id}/stacks"
+      # then the path prefix is ignored and path is only "/stacks"
+      def self.prefix_path_to_ignore
+        ""
+      end
+
+      def headers_default
+        Misty::HEADER_JSON
+      end
+
+      def headers
+        h = headers_default.merge("X-Auth-Token" => "#{@cloud.auth.get_token}")
+        h.merge!(microversion_header) if microversion
+        h
+      end
+
+      private
+
+      def baseclass
+        self.class.to_s.split('::')[-1]
+      end
+
+      def net_http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.set_debug_output($stdout) if @cloud.log.level == Logger::DEBUG
+        if uri.scheme == "https"
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @options[:ssl_verify_mode]
+        end
+        http
+      end
+
+      def setup(params)
+        options = Options.new()
+        options.base_path       = params[:base_path]       ? params[:base_path] : nil
+        options.base_url        = params[:base_url]        ? params[:base_url] : nil
+        options.interface       = params[:interface]       ? params[:interface] : "public"
+        options.region_id       = params[:region_id]       ? params[:region_id] : "regionOne"
+        options.service_names   = params[:service_name]    ? self.class.service_names << params[:service_name] : self.class.service_names
+        options.ssl_verify_mode = params[:ssl_verify_mode] ? params[:ssl_verify_mode] : true
+        options.version         = params[:version]         ? params[:version] : "CURRENT"
+
+        unless INTERFACES.include?(options.interface)
+          raise InvalidDataError, "Options ':interface'must be one of #{INTERFACES}"
+        end
+
+        unless options.ssl_verify_mode == !!options.ssl_verify_mode
+          raise InvalidDataError, "Options ':ssl_verify_mode' must be a boolean"
+        end
+        options
+      end
+    end
+  end
+end

data/lib/misty/http/direct.rb

@@ -0,0 +1,26 @@
+module Misty
+  module HTTP
+    # Provides methods to submit the current service with a path and override @base_path if needed
+    module Direct
+      def base_set(base_path)
+        base = base_path ? base_path : @base_path
+      end
+
+      def delete(path, base_path = nil)
+        http_delete(base_set(base_path) + path, headers)
+      end
+
+      def get(path, base_path = nil)
+        http_get(base_set(base_path) + path, headers)
+      end
+
+      def post(path, data, base_path = nil)
+        http_post(base_set(base_path) + path, headers, data)
+      end
+
+      def put(path, data, base_path = nil)
+        http_put(base_set(base_path) + path, headers, data)
+      end
+    end
+  end
+end

data/lib/misty/http/method_builder.rb

@@ -0,0 +1,96 @@
+module Misty
+  module HTTP
+    module MethodBuilder
+      def method_missing(method_name, *args)
+        if method = get_method(method_name)
+          method_call(method, *args)
+        else
+          raise NoMethodError, "API #{baseclass.downcase}: method #{method_name} not implemented!"
+        end
+      end
+
+      private
+
+      def method_call(method, *args)
+        base, path = prefixed_path(method[:path])
+        size_path_parameters = count_path_params(path)
+        path_params = args[0, size_path_parameters]
+        args_left = args - path_params
+        path = inject_elements(path, path_params)
+        final_path = base_filter(base, path)
+
+        case method[:request]
+        when :COPY
+          http_copy(final_path, headers)
+        when :DELETE
+          http_delete(final_path, headers)
+        when :GET
+          final_path << query_param(args_left[0]) if args_left && args_left.size == 1
+          http_get(final_path, headers)
+        when :HEAD
+          http_head(final_path, headers, data)
+        when :POST
+          data = args_left[0] if args_left && args_left.size == 1
+          http_post(final_path, headers, data)
+        when :PUT
+          data = args_left[0] if args_left && args_left.size == 1
+          http_put(final_path, headers, data)
+        when :PATCH
+          data = args_left[0] if args_left && args_left.size == 1
+          http_patch(final_path, headers, data)
+        else
+          raise SyntaxError, "Invalid HTTP request: #{method[:request]}"
+        end
+      end
+
+      def base_filter(base, path)
+        return (@base_path + path) if base
+        return path
+      end
+
+      def count_path_params(str)
+        subpath = /(.*)(\{.*\})(.*)/.match(str)
+        return 0 unless subpath
+        return count_path_params(subpath[1]) + 1
+      end
+
+      def get_method(name)
+        self.class.api.each do |path, requests|
+          requests.each do |request, methods_list|
+            if methods_list.include?(name)
+              return {:path => path, :request => request, :name => name}
+            end
+          end
+        end
+        nil
+      end
+
+      def inject_elements(str, args)
+        subpath = /(.*)(\{.*\})(.*)/.match(str)
+        return str unless subpath
+        arg = args.pop
+        raise ArgumentError, "Not enough arguments" unless arg
+        return inject_elements(subpath[1], args) + arg + subpath[3]
+      end
+
+      def prefixed_path(path)
+        unless self.class.prefix_path_to_ignore.empty?
+          if path =~ %r{#{self.class.prefix_path_to_ignore}}
+            return true, path.gsub(self.class.prefix_path_to_ignore, '')
+          else
+            return false, path
+          end
+        end
+        return true, path
+      end
+
+      def query_param(data)
+        if data.is_a? String
+          str = '?'
+          str.force_encoding('ASCII-8BIT')
+          str << data unless data.empty?
+        end
+      end
+    end
+  end
+end

data/lib/misty/http/request.rb

@@ -0,0 +1,75 @@
+module Misty
+  module HTTP
+    module Request
+      def decode?(response)
+        if @cloud.content_type != :json && response.code =~ /2??/  && !response.is_a?(Net::HTTPNoContent) \
+          && !response.is_a?(Net::HTTPResetContent) && response.header["content-type"] \
+          && response.header["content-type"].include?("application/json")
+          true
+        end
+      end
+
+      def http(request)
+        response = @http.request(request)
+        response.body = JSON.load(response.body) if decode?(response)
+        response
+      end
+
+      def http_delete(path, headers)
+        @cloud.log.info(http_to_s(path, headers))
+        request = Net::HTTP::Delete.new(path, headers)
+        http(request)
+      end
+
+      def http_copy(path, headers)
+        @cloud.log.info(http_to_s(path, headers))
+        request = Net::HTTP::Copy.new(path, headers)
+        http(request)
+      end
+
+      def http_get(path, headers)
+        @cloud.log.info(http_to_s(path, headers))
+        request = Net::HTTP::Get.new(path, headers)
+        http(request)
+      end
+
+      def http_head(path, headers)
+        @cloud.log.info(http_to_s(path, headers))
+        request = Net::HTTP::Head.new(path, headers)
+        http(request)
+      end
+
+      def http_options(path, headers)
+        @cloud.log.info(http_to_s(path, headers))
+        request = Net::HTTP::Options.new(path, headers)
+        http(request)
+      end
+
+      def http_patch(path, headers, data)
+        @cloud.log.info(http_to_s(path, headers, data))
+        request = Net::HTTP::Patch.new(path, headers)
+        request.body = Misty.to_json(data)
+        http(request)
+      end
+
+      def http_post(path, headers, data)
+        @cloud.log.info(http_to_s(path, headers, data))
+        request = Net::HTTP::Post.new(path, headers)
+        request.body = Misty.to_json(data)
+        http(request)
+      end
+
+      def http_put(path, headers, data)
+        @cloud.log.info(http_to_s(path, headers, data))
+        request = Net::HTTP::Put.new(path, headers)
+        request.body = Misty.to_json(data)
+        http(request)
+      end
+
+      def http_to_s(path, headers, data = nil)
+        log = "base_url='#{@uri.host}:#{@uri.port}', path='#{path}', header=#{headers}"
+        log << ", data='#{data}'" if data
+      end
+    end
+  end
+end