aviator 0.0.1 → 0.0.2

data/lib/aviator/core/response.rb

@@ -0,0 +1,33 @@
+module Aviator
+
+  class Response
+    
+    
+    def method_missing(name, *args)
+      case name
+      when :body
+        @body ||= JSON.parse(response.body).with_indifferent_access
+        @body.dup
+      when :headers, :status
+        response.send(name)
+      when :request
+        request
+      else
+        super(name, *args)
+      end
+    end
+    
+    
+    private
+    
+    attr_reader :response,
+                :request
+    
+    def initialize(response, request)
+      @response = response
+      @request  = request
+    end
+    
+  end
+  
+end

data/lib/aviator/core/service.rb

@@ -0,0 +1,203 @@
+module Aviator
+
+  class Service
+
+    class AccessDetailsNotDefinedError < StandardError
+      def initialize
+        super ":access_details is not defined."
+      end
+    end
+
+    class ProviderNotDefinedError < StandardError
+      def initialize
+        super ":provider is not defined."
+      end
+    end
+
+    class ServiceNameNotDefinedError < StandardError
+      def initialize
+        super ":service is not defined."
+      end
+    end
+
+    class SessionDataNotProvidedError < StandardError
+      def initialize
+        super "default_session_data is not initialized and no session data was "\
+              "provided in the method call."
+      end
+    end
+
+
+    class UnknownRequestError < StandardError
+      def initialize(request_name)
+        super "Unknown request #{ request_name }."
+      end
+    end
+
+
+    class Logger < Faraday::Response::Logger      
+      def initialize(app, logger=nil)
+        super(app)
+        @logger = logger || begin
+          require 'logger'
+          ::Logger.new(self.class::LOG_FILE_PATH)
+        end
+      end
+    end
+
+    # Because we define requests in a flattened scope, we want to make sure that when each
+    # request is initialized it doesn't get polluted by instance variables and methods
+    # of the containing class. This builder class makes that happen by being a
+    # scope gate for the file. See Metaprogramming Ruby, specifically on blocks and scope
+    class RequestBuilder
+
+      # This method gets called by the request file eval'd in self.build below
+      def define_request(request_name, &block)
+        klass = Class.new(Aviator::Request, &block)
+        return klass, request_name
+      end
+
+
+      def self.build(path_to_request_file)
+        clean_room = new
+        clean_room.instance_eval(File.read(path_to_request_file))
+      end
+
+
+      private_class_method :new
+
+    end
+
+
+    attr_accessor :default_session_data
+
+    attr_reader :service,
+                :provider
+                
+
+    def initialize(opts={})
+      @provider = opts[:provider] || (raise ProviderNotDefinedError.new)
+      @service  = opts[:service]  || (raise ServiceNameNotDefinedError.new)
+      @log_file = opts[:log_file]
+
+      @default_session_data = opts[:default_session_data]
+
+      load_requests
+    end
+
+
+    def request(request_name, options={}, &params)
+      session_data = options[:session_data] || default_session_data
+
+      raise SessionDataNotProvidedError.new unless session_data
+
+      request_class = find_request(request_name, session_data, options[:endpoint_type])
+
+      raise UnknownRequestError.new(request_name) unless request_class
+
+      request  = request_class.new(session_data, &params)
+
+      response = http_connection.send(request.http_method) do |r|
+        r.url        request.url
+        r.headers.merge!(request.headers)        if request.headers?
+        r.query    = request.querystring         if request.querystring?
+        r.body     = JSON.generate(request.body) if request.body?
+      end
+
+      Aviator::Response.send(:new, response, request)
+    end
+
+
+    def requests
+      @requests
+    end
+    
+    
+    private
+
+
+    def http_connection
+      @http_connection ||= Faraday.new do |conn|
+        if log_file
+          # Ugly hack to make logger configurable
+          const_name = 'LOG_FILE_PATH'
+          Logger.send(:remove_const, const_name) if Logger.const_defined?(const_name)
+          Logger.const_set(const_name, log_file)
+          conn.use     Logger.dup
+        end
+        conn.adapter Faraday.default_adapter
+        conn.headers['Content-Type'] = 'application/json'
+      end
+    end
+
+
+    # Candidate for extraction to aviator/openstack
+    def find_request(name, session_data, endpoint_type=nil)
+      endpoint_types = if endpoint_type
+                         [endpoint_type.to_sym]
+                       else
+                         [:public, :admin]
+                       end
+
+      version = infer_version(session_data)
+
+      return nil unless version && requests[version]
+
+      endpoint_types.each do |endpoint_type|
+        next unless requests[version][endpoint_type]
+        pair = requests[version][endpoint_type].find{ |k, v| k == name }
+        return pair[1] unless pair.nil?
+      end
+
+      nil
+    end
+
+
+    # Candidate for extraction to aviator/openstack
+    def infer_version(session_data)
+      if session_data.has_key?(:auth_service) && session_data[:auth_service][:api_version]
+        session_data[:auth_service][:api_version].to_sym
+
+      elsif session_data.has_key?(:auth_service) && session_data[:auth_service][:host_uri]
+        m = session_data[:auth_service][:host_uri].match(/(v\d+)\.?\d*/)
+        return m[1].to_sym unless m.nil?
+
+      elsif session_data.has_key? :access
+        service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == service }
+        service_spec[:endpoints][0][:publicURL].match(/(v\d+)\.?\d*/)[1].to_sym
+      end
+    end
+
+
+    def load_requests
+      # TODO: This should be determined by a provider-specific module.
+      # e.g. Aviator::OpenStack::requests_base_dir
+      request_file_paths = Dir.glob(Pathname.new(__FILE__).join(
+                             '..',
+                             '..',
+                             provider.to_s,
+                             service.to_s,
+                             '**',
+                             '*.rb'
+                             ).expand_path
+                           )
+
+      @requests ||= {}
+
+      request_file_paths.each do |path_to_file|
+        klass, request_name = RequestBuilder.build(path_to_file)
+
+        api_version   = @requests[klass.api_version] ||= {}
+        endpoint_type = api_version[klass.endpoint_type] ||= {}
+        endpoint_type[request_name] = klass
+      end
+    end
+    
+    
+    def log_file
+      @log_file
+    end
+
+  end
+
+end

data/lib/aviator/core/session.rb

@@ -0,0 +1,187 @@
+module Aviator
+
+  class Session
+
+    class AuthenticationError < StandardError
+      def initialize(last_auth_body)
+        super("Authentication failed. The server returned #{ last_auth_body }")
+      end
+    end
+    
+    
+    class EnvironmentNotDefinedError < ArgumentError
+      def initialize(path, env)
+        super("The environment '#{ env }' is not defined in #{ path }.")
+      end
+    end
+
+
+    class InvalidConfigFilePathError < ArgumentError
+      def initialize(path)
+        super("The config file at #{ path } does not exist!")
+      end
+    end
+    
+    
+    class NotAuthenticatedError < StandardError
+      def initialize
+        super("Session is not authenticated. Please authenticate before proceeding.")
+      end
+    end
+
+
+    class ValidatorNotDefinedError < StandardError
+      def initialize
+        super("The validator request name is not defined for this session object.")
+      end
+    end
+
+
+    def initialize(opts={})
+      config_path  = opts[:config_file]
+      environment  = opts[:environment]
+      session_dump = opts[:session_dump]
+      
+      if session_dump
+        initialize_with_dump(session_dump)
+      else
+        initialize_with_config(config_path, environment)
+      end
+      
+      @log_file = opts[:log_file]
+    end
+    
+    
+    def authenticate(&block)      
+      block ||= lambda do |params|
+        environment[:auth_credentials].each do |key, value|
+          params[key] = value
+        end
+      end
+
+      response = auth_service.request environment[:auth_service][:request].to_sym, &block
+      
+      if response.status == 200
+        @auth_info = response.body
+        update_services_session_data
+      else
+        raise AuthenticationError.new(response.body)
+      end
+    end
+
+
+    def authenticated?
+      !auth_info.nil?
+    end
+    
+    
+    def dump
+      JSON.generate({
+        environment: environment,
+        auth_info:   auth_info
+      })
+    end
+    
+    
+    def method_missing(name, *args, &block)
+      service_name_parts = name.to_s.match(/^(\w+)_service$/)
+      
+      if service_name_parts
+        get_service_obj(service_name_parts[1])
+      else
+        super name, *args, &block
+      end
+    end
+    
+    
+    def self.load(session_dump, opts={})
+      opts[:session_dump] = session_dump
+      
+      new(opts)
+    end
+    
+    
+    def validate
+      raise NotAuthenticatedError.new unless authenticated?
+      raise ValidatorNotDefinedError.new unless environment[:auth_service][:validator]
+      
+      response = auth_service.request environment[:auth_service][:validator].to_sym, session_data: auth_info
+      
+      response.status == 200 || response.status == 203
+    end
+    
+    
+    private
+
+
+    def auth_info
+      @auth_info
+    end
+    
+    
+    def auth_service
+      @auth_service ||= Service.new(
+        provider: environment[:provider],
+        service:  environment[:auth_service][:name],
+        default_session_data: { auth_service: environment[:auth_service] },
+        log_file: log_file
+      )
+    end
+    
+        
+    def environment
+      @environment
+    end
+
+
+    def get_service_obj(service_name)
+      raise NotAuthenticatedError.new unless self.authenticated?
+      
+      @services ||= {}
+      
+      @services[service_name] ||= Service.new(
+        provider: environment[:provider],
+        service:  service_name,
+        default_session_data: auth_info,
+        log_file: log_file
+      )
+      
+      @services[service_name]
+    end
+
+
+    def initialize_with_config(config_path, environment)
+      raise InvalidConfigFilePathError.new(config_path) unless Pathname.new(config_path).file?
+
+      config = YAML.load_file(config_path).with_indifferent_access
+
+
+      raise EnvironmentNotDefinedError.new(config_path, environment) unless config[environment]
+
+      @environment = config[environment]
+    end
+    
+    
+    def initialize_with_dump(session_dump)
+      session_info = JSON.parse(session_dump).with_indifferent_access
+      @environment = session_info[:environment]
+      @auth_info   = session_info[:auth_info]
+    end
+        
+    
+    def log_file
+      @log_file
+    end
+    
+    
+    def update_services_session_data
+      return unless @services
+      
+      @services.each do |name, obj|
+        obj.default_session_data = auth_info
+      end
+    end
+      
+  end
+
+end

data/lib/aviator/openstack/compute/v2/public/list_images.rb

@@ -0,0 +1,49 @@
+define_request :list_images do
+
+  endpoint_type :public
+  api_version   :v2
+  http_method   :get
+
+  link_to 'documentation',
+          'http://docs.openstack.org/api/openstack-compute/2/content/List_Images-d1e4435.html'
+
+  optional_param :details
+  optional_param :server
+  optional_param :name
+  optional_param :status
+  optional_param 'changes-since'
+  optional_param :marker
+  optional_param :limit
+  optional_param :type
+
+
+
+  def url
+    service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'compute' }
+    
+    str  = "#{ service_spec[:endpoints][0][:publicURL] }/images"
+    str += "/detail" if params[:details]
+    
+    filters = []
+    
+    (optional_params + required_params - [:details]).each do |param_name|
+      filters << "#{ param_name }=#{ params[param_name] }" if params[param_name]
+    end
+    
+    str += "?#{ filters.join('&') }" unless filters.empty?
+    
+    str
+  end
+
+
+  def headers
+    h = {}
+    
+    unless self.anonymous?
+      h['X-Auth-Token'] = session_data[:access][:token][:id]
+    end
+
+    h
+  end
+
+end