solvebio 1.6.1 → 1.7.0

data/lib/solvebio/api_resource.rb

@@ -0,0 +1,32 @@
+module SolveBio
+    class APIResource < SolveObject
+        def self.retrieve(id)
+            instance = self.new(id)
+            instance.refresh()
+            instance
+        end
+
+        def self.class_name
+            self.name.split('::')[-1]
+        end
+
+        def self.url
+            if self == APIResource
+                raise NotImplementedError.new('APIResource is an abstract class and has no url.')
+            end
+            "/v1/#{Util.pluralize(Util.camelcase_to_underscore(class_name))}"
+        end
+
+        def url
+            unless id = self.id
+                raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+            end
+            "#{self.class.url}/#{id}"
+        end
+
+        def refresh
+            response = Client.get(url)
+            refresh_from(response)
+        end
+    end
+end

data/lib/solvebio/cli.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'irb'
+require 'netrc'
+require 'fileutils'
+require 'optparse'
+require 'readline'
+require 'io/console'
+
+require 'solvebio/cli/credentials'
+require 'solvebio/cli/auth'
+require 'solvebio/cli/irb'
+require 'solvebio/cli/tutorial'
+
+module SolveBio
+    module CLI
+        def process_options(argv)
+            options = {}
+            opts = setup_options(options)
+
+            begin
+                opts.parse!(argv)
+            rescue OptionParser::ParseError => error
+                $stderr.puts error
+                $stderr.puts "(-h or --help will show valid options)"
+                exit 1
+            end
+
+            SolveBio.api_host = options[:api_host] if options[:api_host]
+            SolveBio.api_key = options[:api_key] if options[:api_key]
+            
+            return options, argv
+        end
+
+        # Main parser for the SolveBio command line client
+        def setup_options(options, stdout=$stdout, stderr=$stderr)
+            OptionParser.new do |opts|
+                opts.banner = "Usage: solvebio.rb [options] <command> [<args>]"
+                opts.on_tail('-v', '--version',
+                             'print the version') do
+                    options[:version] = true
+                    stdout.puts "solvebio-ruby #{SolveBio::VERSION}"
+                    exit 0
+                end
+
+                opts.on('--api-host STRING', String,
+                        'Override the default SolveBio API host') do
+                    |api_host|
+                    options[:api_host] = api_host
+                end
+
+                opts.on('--api-key STRING', String,
+                        'Manually provide a SolveBio API key') do
+                    |api_key|
+                    options[:api_key] = api_key
+                end
+
+                opts.on('-h', '--help', 'Display this screen') do
+                    puts opts
+                    puts <<-EOH
+
+SolveBio Commands:
+    login               Login and save credentials.
+    logout              Logout and delete saved credentials.
+    whoami              Show your SolveBio email address.
+    shell               Open a SolveBio IRB shell.
+    tutorial            Start the SolveBio Ruby tutorial.
+EOH
+                    exit
+                end
+            end
+        end
+    end
+end

data/lib/solvebio/cli/auth.rb

@@ -0,0 +1,106 @@
+module SolveBio
+    module CLI
+        module Auth
+            include SolveBio::CLI::Credentials
+
+            module_function
+            def print_message(msg)
+                if SolveBio.api_host != 'https://api.solvebio.com'
+                    msg += " (#{SolveBio.api_host})"
+                end
+                puts msg + '.'
+            end
+
+            def ask_for_credentials()
+                print_message('Enter your SolveBio credentials')
+                email = Readline.readline('Email: ', true)
+                puts 'Password (typing will be hidden): '
+                password = STDIN.noecho(&:gets).chomp
+                puts
+                return email, password
+            end
+
+            def send_install_report
+                require 'rbconfig';
+                data = {
+                    :client                => 'ruby',
+                    :client_version        => SolveBio::VERSION,
+                    :ruby_version          => RbConfig::CONFIG['RUBY_PROGRAM_VERSION'],
+                    :ruby_implementation   => RbConfig::CONFIG['RUBY_SO_NAME'],
+                    :architecture          => RbConfig::CONFIG['arch'],
+                }
+                Client.request('post', '/v1/reports/install', {:payload => data}) rescue nil
+            end
+
+            def login
+                email, password = ask_for_credentials
+        
+                if not email or not password
+                    puts "Email and password are both required."
+                    return false
+                end
+                    
+                data = {
+                    :email    => email,
+                    :password => password
+                }
+
+                begin
+                    response = Client.post('/v1/auth/token', {:payload => data})
+                rescue SolveBio::SolveError => e
+                    puts "Login failed: #{e.to_s}"
+                    return false
+                end
+
+                delete_credentials
+                save_credentials(email.downcase, response[:token])
+                SolveBio.api_key = response[:token]
+                send_install_report
+                print_message("You are now logged-in as #{email}")
+                return true
+            end
+
+            def logout
+                if get_credentials
+                    delete_credentials
+                    print_message('You have been logged out')
+                    return true
+                end
+
+                print_message('You are not logged-in')
+                return false
+            end
+
+            def whoami
+                email = nil
+                api_key = SolveBio.api_key
+                
+                # Override local credentials with existing key
+                if SolveBio.api_key
+                    begin
+                        user = Client.get('/v1/user')
+                        email = user[:email]
+                    rescue SolveBio::SolveError => e
+                        SolveBio.api_key = nil
+                        api_key = nil
+                        print_message("Error: #{e.to_s}")
+                    end
+                else
+                    begin
+                        email, api_key = get_credentials
+                    rescue
+                        nil
+                    end
+                end
+
+                if not email.nil?
+                    print_message("You are logged-in as #{email}")
+                else
+                    print_message("You are not logged-in")
+                end
+
+                return email, api_key
+            end
+        end
+    end
+end

data/lib/solvebio/cli/credentials.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+class CredentialsError < RuntimeError
+end
+
+module SolveBio
+    module CLI
+        module Credentials
+            module_function
+            def api_host
+                Addressable::URI.parse(SolveBio.api_host).host
+            end
+
+            def netrc_path
+                raise IOError, "$HOME is not set and is needed for SolveBio credentials" unless
+                    ENV['HOME']
+
+                path = File.join(ENV['HOME'], '.solvebio', 'credentials')
+
+                dirname = File.dirname(path)
+                FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+
+                # create an empty credentials file if it doesn't exist
+                FileUtils.touch path unless File.exist? path
+                FileUtils.chmod 0600, path
+                path
+            end
+
+            def get_credentials
+                begin
+                    n = Netrc.read(netrc_path)
+                    return n[api_host]
+                rescue Netrc::Error => e
+                    raise CredentialsError, "Could not read credentials file: #{e}"
+                end
+            end
+            module_function :get_credentials
+
+            def delete_credentials
+                n = Netrc.read(netrc_path)
+                n.delete(api_host)
+                n.save
+            end
+
+            def save_credentials(email, api_key)
+                n = Netrc.read(netrc_path)
+                # Overwrites any existing credentials
+                n[api_host] = email, api_key
+                n.save
+            end
+        end
+    end
+end

data/lib/{cli → solvebio/cli}/irb.rb

@@ -1,27 +1,9 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-# Open the SolveBio shell, an IRB wrapper
-require 'irb'
-require_relative 'help'
 
 module IRB
-
-    # Stuff to add IRB commands goes here
-    # module ExtendCommand
-    #     class SolveHelp
-    #         def self.execute(conf, *opts)
-    #             SolveBio::help
-    #         end
-    #     end
-
-    # end
-
     module_function
-
-    # ExtendCommandBundle.def_extend_command 'solvehelp', :SolveHelp
-
     def shell
-
         # Set to run the standard trepan IRB profile
         irbrc = File.
             expand_path(File.join(File.dirname(__FILE__), 'irbrc.rb'))
@@ -51,8 +33,3 @@ module IRB
         end
     end
 end
-
-# Demo it.
-if __FILE__ == $0
-    IRB::shell
-end

data/lib/solvebio/cli/irbrc.rb

@@ -0,0 +1,48 @@
+# -*- ruby -*-
+# irbrc profile for SolveBio
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:PROMPT][:SIMPLE] = {
+  :PROMPT_C => '[SolveBio] In ?: ',  # Prompt when continuing a statement
+  :PROMPT_I => '[SolveBio] In  : ',  # Normal prompt
+  :PROMPT_N => '[SolveBio] In +: ',  # Prompt when indenting code
+  :PROMPT_S => '[SolveBio] In %l: ', # Prompt when continuing a string
+  :RETURN   => "[SolveBio] Out : %s\n"
+ }
+
+require 'solvebio'
+require 'solvebio/cli'
+
+have_completion = nil
+begin
+    require 'bond' and require 'bond/completion'
+    have_completion = 'bond'
+rescue LoadError
+    begin
+        have_completion = require 'irb/completion'
+    rescue LoadError
+        have_completion = false
+    end
+end
+
+unless have_completion
+    if have_completion != 'bond'
+        puts "Please install the 'bond' getm for better autocompletion"
+    end
+end
+
+# If an API key is set in SolveBio.api_key, use that.
+# Otherwise, look for credentials in the local file,
+# Otherwise, ask the user to log in.
+
+if SolveBio.api_key or SolveBio::CLI::Credentials.get_credentials
+    email, SolveBio.api_key = SolveBio::CLI::Auth::whoami
+else
+    SolveBio::CLI::Auth.login
+end
+
+if not SolveBio.api_key
+    puts("SolveBio requires a valid account. To sign up, visit: https://www.solvebio.com/signup")
+    exit 1
+end
+
+include SolveBio

data/lib/solvebio/cli/tutorial.rb

@@ -0,0 +1,12 @@
+module SolveBio
+    module CLI
+        module Tutorial
+            def tutorial
+                puts <<-TUTORIAL
+    # Tutorial coming soon!
+    TUTORIAL
+            end
+            module_function :tutorial
+        end
+    end
+end

data/lib/solvebio/client.rb

@@ -0,0 +1,149 @@
+module SolveBio
+    class Client
+        attr_reader :headers, :api_host
+        attr_accessor :api_key
+
+        # Add our own kind of Authorization tokens. This has to be
+        # done this way, late, because the rest-client gem looks for
+        # .netrc and will set basic authentication if it finds a match.
+        RestClient.add_before_execution_proc do | req, args |
+            if args[:authorization]
+                req.instance_variable_get('@header')['authorization'] = [args[:authorization]]
+            end
+        end
+
+        def initialize(api_key=nil, api_host=nil)
+            @api_key = api_key || SolveBio.api_key
+            @api_host = api_host || SolveBio.api_host
+
+            # Mirroring comments from:
+            # http://ruby-doc.org/stdlib-2.1.2/libdoc/net/http/rdoc/Net/HTTP.html
+            # gzip compression is used in preference to deflate
+            # compression, which is used in preference to no compression.
+            @headers  = {
+                :content_type     => :json,
+                :accept           => :json,
+                'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                'User-Agent'      => 'SolveBio Ruby Client %s' % [
+                    SolveBio::VERSION,
+                ]
+            }
+        end
+
+        DEFAULT_REQUEST_OPTS = {
+            :raw             => false,
+            :default_headers => true
+        }
+
+        # Issues an HTTP GET across the wire via the Ruby 'rest-client'
+        # library. See *request()* for information on opts.
+        def get(url, opts={})
+            request('get', url, opts)
+        end
+
+        # Issues an HTTP POST across the wire via the Ruby 'rest-client'
+        # library. See *request* for information on opts.
+        def post(url, data, opts={})
+            opts[:payload] =
+                if opts.member?(:no_json)
+                    data
+                else
+                    data.to_json
+                end
+            request('post', url, opts)
+        end
+
+        # Issues an HTTP Request across the wire via the Ruby 'rest-client'
+        # library.
+        def request(method, url, opts={})
+            opts = DEFAULT_REQUEST_OPTS.merge(opts)
+
+            # Expand URL with API host if none was given
+            api_host = @api_host or SolveBio.api_host
+
+            if not api_host
+                raise SolveError.new('No SolveBio API host is set')
+            elsif not url.start_with?(api_host)
+                url = Addressable::URI.join(api_host, url).to_s
+            end
+
+            # Handle some default options and add authorization header
+            if opts[:default_headers] and @api_key
+                headers = @headers.merge(opts[:headers]||{})
+                authorization = "Token #{@api_key}"
+            else
+                headers = nil
+                authorization = nil
+            end
+
+            SolveBio::logger.debug('API %s Request: %s' % [method.upcase, url])
+
+            response = nil
+            begin
+                RestClient::Request.
+                    execute(:method        => method,
+                            :url           => url,
+                            :headers       => headers,
+                            :authorization => authorization,
+                            :timeout       => opts[:timeout] || 80,
+                            :payload       => opts[:payload]) do
+                    |resp, request, result, &block|
+                    response = resp
+                    if 429 == response.code
+                        delay = Integer(response.headers[:retry_after])
+                        SolveBio::logger.warn("Too many requests, sleeping for #{delay}s.")
+                        sleep(delay)
+                        return request(method, url, opts)
+                    elsif response.code < 200 or response.code >= 400
+                        handle_api_error(response)
+                    end
+                end
+            rescue RestClient::Exception => e
+                handle_request_error(e)
+            end
+
+            if opts[:raw]
+                return response
+            end
+
+            begin
+                response = JSON.parse(response)
+            rescue JSON::ParserError => e
+                handle_request_error(e)
+            end
+
+            Util.symbolize_names(response)
+        end
+
+        def handle_request_error(e)
+            err = e.inspect
+            SolveBio::logger.error("API Error: #{err}")
+            msg = "Unexpected error communicating with SolveBio.\n" +
+                  "If this problem persists, let us " +
+                  "know at contact@solvebio.com."
+            raise SolveError.new(nil, msg)
+        end
+
+        def handle_api_error(response)
+            SolveBio::logger.error("API Error: #{response}") unless
+                [400, 401, 403, 404].member?(response.code.to_i)
+            raise SolveError.new(response)
+        end
+
+        def self.client
+            @@client ||= SolveBio::Client.new()
+        end
+
+        def self.get(url, opts={})
+            client.get(url, opts)
+        end
+
+        def self.post(url, data, opts={})
+            client.post(url, data, opts)
+        end
+
+        def self.request(method, url, opts={})
+            client.request(method, url, opts)
+        end
+    end
+end