spark_api 1.0.0

data/lib/spark_api/authentication/oauth2_impl/grant_type_password.rb

@@ -0,0 +1,44 @@
+module SparkApi
+  module Authentication
+    module OAuth2Impl
+      # OAuth2 authentication flow using username and password parameters for the user in the 
+      # request.  This implementation is geared towards authentication styles for native 
+      # applications that need to use OAuth2
+      class GrantTypePassword < GrantTypeBase
+        def initialize(client, provider, session)
+          super(client, provider, session)
+        end
+        def authenticate
+          new_session = nil
+          if needs_refreshing?
+            new_session = refresh
+          end
+          return new_session unless new_session.nil?
+          create_session(token_params)
+        end
+        
+        def refresh()
+          GrantTypeRefresh.new(client,provider,session).authenticate
+        rescue ClientError => e
+          SparkApi.logger.info("[oauth2] Refreshing token failed, the library will try and authenticate from scratch: #{e.message}")
+          nil
+        end
+
+        private 
+        def token_params
+          params = {
+            "client_id" => @provider.client_id,
+            "client_secret" => @provider.client_secret,
+            "grant_type" => "password",
+            "username" => @provider.username,
+            "password" => @provider.password,
+          }.to_json 
+        end
+      end
+    end
+  end
+end
+
+
+
+ 

data/lib/spark_api/authentication/oauth2_impl/grant_type_password.rb~

@@ -0,0 +1,45 @@
+
+module FlexmlsApi
+  module Authentication
+    module OAuth2Impl
+      # OAuth2 authentication flow using username and password parameters for the user in the 
+      # request.  This implementation is geared towards authentication styles for native 
+      # applications that need to use OAuth2
+      class GrantTypePassword < GrantTypeBase
+        def initialize(client, provider, session)
+          super(client, provider, session)
+        end
+        def authenticate
+          new_session = nil
+          if needs_refreshing?
+            new_session = refresh
+          end
+          return new_session unless new_session.nil?
+          create_session(token_params)
+        end
+        
+        def refresh()
+          GrantTypeRefresh.new(client,provider,session).authenticate
+        rescue ClientError => e
+          FlexmlsApi.logger.info("[oauth2] Refreshing token failed, the library will try and authenticate from scratch: #{e.message}")
+          nil
+        end
+
+        private 
+        def token_params
+          params = {
+            "client_id" => @provider.client_id,
+            "client_secret" => @provider.client_secret,
+            "grant_type" => "password",
+            "username" => @provider.username,
+            "password" => @provider.password,
+          }.to_json 
+        end
+      end
+    end
+  end
+end
+
+
+
+ 

data/lib/spark_api/authentication/oauth2_impl/grant_type_refresh.rb

@@ -0,0 +1,35 @@
+module SparkApi
+  module Authentication
+    # OAuth2 authentication flow to refresh an access token
+    module OAuth2Impl
+      class GrantTypeRefresh < GrantTypeBase
+        attr_accessor :params
+        def initialize(client, provider, session)
+          super(client, provider, session)
+          @params = {}
+        end
+        
+        def authenticate
+          new_session = nil
+          unless @session.refresh_token.nil?
+            SparkApi.logger.debug("[oauth2] Refreshing authentication to #{provider.access_uri} using [#{session.refresh_token}]")
+            new_session = create_session(token_params)
+          end
+          new_session 
+        end
+        
+        private 
+        def token_params
+          @params.merge({
+            "client_id" => @provider.client_id,
+            "client_secret" => @provider.client_secret,
+            "grant_type" => "refresh_token",
+            "refresh_token"=> session.refresh_token,
+          }).to_json 
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/spark_api/authentication/oauth2_impl/grant_type_refresh.rb~

@@ -0,0 +1,36 @@
+
+module FlexmlsApi
+  module Authentication
+    # OAuth2 authentication flow to refresh an access token
+    module OAuth2Impl
+      class GrantTypeRefresh < GrantTypeBase
+        attr_accessor :params
+        def initialize(client, provider, session)
+          super(client, provider, session)
+          @params = {}
+        end
+        
+        def authenticate
+          new_session = nil
+          unless @session.refresh_token.nil?
+            FlexmlsApi.logger.debug("[oauth2] Refreshing authentication to #{provider.access_uri} using [#{session.refresh_token}]")
+            new_session = create_session(token_params)
+          end
+          new_session 
+        end
+        
+        private 
+        def token_params
+          @params.merge({
+            "client_id" => @provider.client_id,
+            "client_secret" => @provider.client_secret,
+            "grant_type" => "refresh_token",
+            "refresh_token"=> session.refresh_token,
+          }).to_json 
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/spark_api/authentication/oauth2_impl/middleware.rb

@@ -0,0 +1,38 @@
+module SparkApi
+
+  module Authentication
+    
+    module OAuth2Impl
+      
+      #==OAuth2 Faraday response middleware
+      # HTTP Response after filter to package oauth2 responses and bubble up basic api errors.
+      class Middleware < Faraday::Response::ParseJson
+        def on_complete(finished_env)
+          body = parse(finished_env[:body])
+          SparkApi.logger.debug("[oauth2] Response Body: #{body.inspect}")
+          unless body.is_a?(Hash)
+            raise InvalidResponse, "The server response could not be understood"
+          end
+          case finished_env[:status]
+          when 200..299
+            SparkApi.logger.debug("[oauth2] Success!")
+            session = OAuthSession.new(body)
+          else 
+            # Handle the WWW-Authenticate Response Header Field if present. This can be returned by 
+            # OAuth2 implementations and wouldn't hurt to log.
+            auth_header_error = finished_env[:request_headers]["WWW-Authenticate"]
+            SparkApi.logger.warn("Authentication error #{auth_header_error}") unless auth_header_error.nil?
+            raise ClientError, {:message => body["error"], :code =>0, :status => finished_env[:status]}
+          end
+          SparkApi.logger.debug("[oauth2] Session=#{session.inspect}")
+          finished_env[:body] = session
+        end
+    
+        def initialize(app)
+          super(app)
+        end
+        
+      end
+    end
+  end
+end

data/lib/spark_api/authentication/oauth2_impl/middleware.rb~

@@ -0,0 +1,39 @@
+
+module FlexmlsApi
+
+  module Authentication
+    
+    module OAuth2Impl
+      
+      #==OAuth2 Faraday response middleware
+      # HTTP Response after filter to package oauth2 responses and bubble up basic api errors.
+      class Middleware < Faraday::Response::ParseJson
+        def on_complete(finished_env)
+          body = parse(finished_env[:body])
+          FlexmlsApi.logger.debug("[oauth2] Response Body: #{body.inspect}")
+          unless body.is_a?(Hash)
+            raise InvalidResponse, "The server response could not be understood"
+          end
+          case finished_env[:status]
+          when 200..299
+            FlexmlsApi.logger.debug("[oauth2] Success!")
+            session = OAuthSession.new(body)
+          else 
+            # Handle the WWW-Authenticate Response Header Field if present. This can be returned by 
+            # OAuth2 implementations and wouldn't hurt to log.
+            auth_header_error = finished_env[:request_headers]["WWW-Authenticate"]
+            FlexmlsApi.logger.warn("Authentication error #{auth_header_error}") unless auth_header_error.nil?
+            raise ClientError, {:message => body["error"], :code =>0, :status => finished_env[:status]}
+          end
+          FlexmlsApi.logger.debug("[oauth2] Session=#{session.inspect}")
+          finished_env[:body] = session
+        end
+    
+        def initialize(app)
+          super(app)
+        end
+        
+      end
+    end
+  end
+end

data/lib/spark_api/authentication/oauth2_impl/password_provider.rb

@@ -0,0 +1,24 @@
+module SparkApi
+  module Authentication
+    module OAuth2Impl
+      class PasswordProvider < SparkApi::Authentication::BaseOAuth2Provider
+        def initialize(credentials)
+          super(credentials)
+          @grant_type = :password
+        end
+        
+        def load_session()
+          @session
+        end
+      
+        def save_session(session)
+          @session = session
+        end
+      
+        def destroy_session
+          @session = nil
+        end
+      end
+    end
+  end
+end

data/lib/spark_api/authentication/oauth2_impl/password_provider.rb~

@@ -0,0 +1,25 @@
+
+module FlexmlsApi
+  module Authentication
+    module OAuth2Impl
+      class PasswordProvider < FlexmlsApi::Authentication::BaseOAuth2Provider
+        def initialize(credentials)
+          super(credentials)
+          @grant_type = :password
+        end
+        
+        def load_session()
+          @session
+        end
+      
+        def save_session(session)
+          @session = session
+        end
+      
+        def destroy_session
+          @session = nil
+        end
+      end
+    end
+  end
+end

data/lib/spark_api/cli.rb

@@ -0,0 +1,158 @@
+require 'optparse'
+
+if ENV["SPARK_API_CONSOLE"].nil?
+  require 'spark_api'
+else
+  puts "Enabling console mode for local gem"
+  Bundler.require(:default, "development") if defined?(Bundler)
+  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  require path + '/spark_api'
+end
+
+module SparkApi
+  module CLI
+    class ConsoleCLI
+      OPTIONS_ENV = {
+        :endpoint          => "API_ENDPOINT",
+        # OAUTH2 Options
+        :access_uri  => "ACCESS_URI",
+        :username=> "USERNAME",
+        :password=> "PASSWORD",
+        :client_id=> "CLIENT_ID",
+        :client_secret=> "CLIENT_SECRET",
+        # API AUTH Options
+        :api_key => "API_KEY", 
+        :api_secret => "API_SECRET",
+        :api_user => "API_USER",
+        # OTHER
+        :debug=> "DEBUG",
+        :console => "SPARK_API_CONSOLE"  # not a public option, meant to distinguish bin/spark_api and script/console
+      }
+      
+      def self.execute(stdout, arguments=[])
+        options = setup_options(stdout,arguments)
+        libs =  " -r irb/completion"
+        # Perhaps use a console_lib to store any extra methods I may want available in the cosole
+        libs << (options[:oauth2] ? setup_oauth2 : setup_api_auth)
+        
+        bundler = (options[:console] ? "bundle exec" : "")  
+        cmd = "#{export_env(options)} #{bundler} #{irb} #{libs} --simple-prompt"
+        puts "Loading spark_api gem..."
+        exec "#{cmd}"
+      end
+      
+      def self.irb()
+        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+      end
+      
+      private
+      def self.setup_options(stdout,arguments)
+        env_options = {
+          :oauth2            => false,
+          :endpoint          => ENV[OPTIONS_ENV[:endpoint]],
+          # OAUTH2 Options
+          :access_uri  => ENV[OPTIONS_ENV[:access_uri]],
+          :username=> ENV[OPTIONS_ENV[:username]],
+          :password=> ENV[OPTIONS_ENV[:password]],
+          :client_id=> ENV[OPTIONS_ENV[:client_id]],
+          :client_secret=> ENV[OPTIONS_ENV[:client_secret]],
+          # API AUTH Options
+          :api_key => ENV[OPTIONS_ENV[:api_key]], 
+          :api_secret => ENV[OPTIONS_ENV[:api_secret]],
+          :api_user => ENV[OPTIONS_ENV[:api_user]],
+          :console => ENV[OPTIONS_ENV[:console]]
+        }
+        cli_options = {}
+        file_options = {}
+        parser = OptionParser.new do |opts|
+          opts.banner = <<-BANNER.gsub(/^          /,'')
+            #{version}
+            SparkApi Client Console - http://sparkplatform.com/docs/overview/api
+            
+            Usage: #{File.basename($0)} [options]
+            
+            Environment Variables: some options (as indicated below), will default to values of keys set in the environment. 
+        
+            Options are:
+          BANNER
+          opts.separator ""
+          opts.on("-o","--oauth2",
+                  "Run the API using OAuth2 credentials.  The client defaults to using the Spark API authentication mode for access. ",
+                  "See http://sparkplatform.com/docs/authentication/authentication for more information on authentication types.",
+                  "Default: false") { |arg| cli_options[:oauth2] = arg }
+          opts.on("-e","--endpoint ENDPOINT",
+                  "URI of the API.",
+                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}']") { |arg| cli_options[:endpoint] = arg }
+
+          # OAUTH2
+          opts.on("--client_id CLIENT_ID",
+                  "OAuth2 client id",
+                  "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| cli_options[:client_id] = arg }
+          opts.on("--client_secret CLIENT_SECRET",
+                  "OAuth2 client secret",
+                  "Default: ENV['#{OPTIONS_ENV[:client_secret]}']") { |arg| cli_options[:client_secret] = arg }
+          opts.on("-u","--username USERNAME",
+                  "OAuth2 username",
+                  "Default: ENV['#{OPTIONS_ENV[:username]}']") { |arg| cli_options[:username] = arg }
+          opts.on("-p","--password PASSWORD",
+                  "OAuth2 password",
+                  "Default: ENV['#{OPTIONS_ENV[:password]}']") { |arg| cli_options[:password] = arg }
+          opts.on("--access_uri ACCESS_URI",
+                  "OAuth2 path for granting access to the application",
+                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}']") { |arg| cli_options[:access_uri] = arg }
+                    
+          # API AUTH
+          opts.on("--api_key API_KEY",
+                  "Authentication key for running the api using the default api authentication",
+                  "Default: ENV['#{OPTIONS_ENV[:api_key]}']") { |arg| cli_options[:api_key] = arg }
+          opts.on("--api_secret API_SECRET",
+                  "API secret for the api key",
+                   "Default: ENV['#{OPTIONS_ENV[:api_secret]}']") { |arg| cli_options[:api_secret] = arg }
+          opts.on("--api_user API_USER",
+                  "ID of the Spark user to run the client as.",
+                  "Default: ENV['#{OPTIONS_ENV[:api_user]}']") { |arg| cli_options[:api_user] = arg }
+                    
+          opts.on("-f", "--file FILE",
+                  "Load configuration for yaml file.") { |arg| file_options = parse_file_options(arg) }
+          opts.on("-d", "--debug",
+                  "Show detailed request logging information.") { |arg| cli_options[:debug] = arg }
+          opts.on("-v", "--version",
+                  "Show client version.") { stdout.puts version; exit }
+          opts.on("-h", "--help",
+                  "Show this help message.") { stdout.puts opts; exit }
+          opts.parse!(arguments)
+        
+        end
+        options = env_options.merge(file_options.merge(cli_options))
+        return options
+      end
+      
+      def self.setup_api_auth
+        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/api_auth.rb'}"
+      end
+  
+      def self.setup_oauth2
+        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/oauth2.rb'}"
+      end
+      
+      def self.export_env(options)
+        run_env = ""
+        OPTIONS_ENV.each do |k,v|
+          run_env << " #{v}=\"#{options[k]}\"" unless options[k].nil?
+        end
+        run_env
+      end
+      
+      private 
+      def self.parse_file_options(file)
+        yaml = SparkApi::Configuration::YamlConfig.new(file)
+        return {:oauth2 => yaml.oauth2}.merge(yaml.client_keys.merge(yaml.oauth2_keys))
+      end
+      
+      def self.version
+        "SparkApi v#{SparkApi::VERSION}"
+      end
+    end
+  end
+end