openbel-api 0.4.0-java

data/app/openbel/api/app.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+
+# TODO This should probably be in app-config.rb.
+require 'jrjackson'
+
+require_relative 'util'
+
+require 'rack/cors'
+require 'sinatra/base'
+require "sinatra/reloader"
+require "sinatra/cookies"
+
+require_relative 'config'
+require_relative 'routes/base'
+require_relative 'routes/root'
+require_relative 'routes/annotations'
+require_relative 'routes/evidence'
+require_relative 'routes/datasets'
+require_relative 'routes/expressions'
+require_relative 'routes/functions'
+require_relative 'routes/namespaces'
+require_relative 'routes/authenticate'
+require_relative 'middleware/auth'
+
+module OpenBEL
+
+  class Server < Sinatra::Application
+
+    configure :development do
+      register Sinatra::Reloader
+    end
+
+    configure do
+      config = OpenBEL::Config::load!
+      OpenBEL.const_set :Settings, config
+    end
+
+    if OpenBEL::Settings[:auth][:enabled]
+      enable :sessions
+      set :session_secret, OpenBEL::Settings['session_secret']
+    end
+
+    use Rack::Deflater
+    use Rack::Cors do
+      allow do
+        origins '*'
+        resource '*',
+          :headers     => :any,
+          :methods     => [ :get, :post, :put, :delete, :options ],
+          :max_age     => 1,
+          :credentials => false,
+          :expose      => [
+            'Allow',
+            'Content-Type',
+            'Content-Encoding',
+            'Content-Length',
+            'ETag',
+            'Last-Modified',
+            'Link',
+            'Location'
+          ]
+      end
+    end
+    disable :protection
+
+    # routes not requiring authentication
+    use OpenBEL::Routes::Root
+    use OpenBEL::Routes::Annotations
+    use OpenBEL::Routes::Expressions
+    use OpenBEL::Routes::Functions
+    use OpenBEL::Routes::Namespaces
+    use OpenBEL::Routes::Authenticate
+
+    # routes requiring authentication
+    if OpenBEL::Settings[:auth][:enabled]
+      use OpenBEL::JWTMiddleware::Authentication
+    end
+    use OpenBEL::Routes::Datasets
+    use OpenBEL::Routes::Evidence
+  end
+end
+# vim: ts=2 sts=2 sw=2
+# encoding: utf-8

data/app/openbel/api/config.rb

@@ -0,0 +1,45 @@
+require 'dot_hash'
+
+module OpenBEL
+  module Config
+    include DotHash
+
+    CFG_VAR = 'OPENBEL_API_CONFIG_FILE'
+
+    def self.load!
+      config_file = ENV[CFG_VAR] || raise('No OpenBEL API configuration found. Set the OPENBEL_API_CONFIG_FILE environment variable.')
+      config = {}
+      File.open(config_file, 'r:UTF-8') do |cf|
+        config = YAML::load(cf)
+        if not config
+          config = {}
+        end
+      end
+      cfg = Settings.new config, SilentProperties
+
+      failure = validate cfg
+      if failure
+        if block_given?
+          yield failure[1]
+        else
+          fail "Configuration error: #{failure[1]}"
+        end
+      end
+
+      cfg
+    end
+
+    private
+
+    def self.validate(cfg)
+      nil
+    end
+
+    class SilentProperties < Properties
+      def method_missing(key, *args, &block)
+        return nil unless has_key?(key)
+        execute(key, *args, &block)
+      end
+    end
+  end
+end

data/app/openbel/api/config.ru

@@ -0,0 +1,3 @@
+require_relative 'app'
+
+run OpenBEL::Server

data/app/openbel/api/helpers/pager.rb

@@ -0,0 +1,109 @@
+module OpenBEL
+  module Helpers
+
+    class Pager
+
+      NEGATIVE_FUNCTION      = lambda { |v| v < 0 ? 0 : v }
+      FLOAT_FUNCTION         = lambda { |v| Float(v)      }
+      PREVIOUS_COND_FUNCTION = lambda { |pager, neg_proc, pos_proc|
+        [
+          pager.start_offset,
+          pager.page_size,
+        ].any?(&(lambda { |v| v <= 0 })) ?
+          neg_proc.call(pager) :
+          pos_proc.call(pager)
+      }
+      NEXT_COND_FUNCTION = lambda { |pager, false_proc, true_proc|
+        test  = pager.page_size > 0
+        test &= (pager.start_offset + pager.page_size) <= pager.total_size
+
+        test ?
+          true_proc.call(pager) :
+          false_proc.call(pager)
+      }
+
+      private_constant :NEGATIVE_FUNCTION
+      private_constant :FLOAT_FUNCTION
+      private_constant :PREVIOUS_COND_FUNCTION
+      private_constant :NEXT_COND_FUNCTION
+
+      def initialize(start_offset, page_size, total_size)
+        raise ArgumentError.new("start_offset must be >= 0") if start_offset < 0
+        raise ArgumentError.new("page_size must be >= 0") if page_size < 0
+        raise ArgumentError.new("total_size must be >= 0") if total_size < 0
+
+        @start_offset = NEGATIVE_FUNCTION.call(start_offset)
+        @page_size    = FLOAT_FUNCTION.call(page_size)
+        @total_size   = total_size
+      end
+
+      def start_offset
+        @start_offset
+      end
+
+      def current_page
+        return 0 if @total_size == 0
+
+        if @page_size > 0
+          ((@start_offset + @page_size) / @page_size).floor
+        else
+          total_pages = total_pages()
+
+          case total_pages
+          when 1
+            1
+          when 2
+            midpoint = @total_size / total_pages
+            @start_offset < midpoint ? 1 : 2
+          end
+        end
+      end
+
+      def page_size
+        @page_size.to_i
+      end
+
+      def total_pages
+        return 0 if @total_size == 0
+
+        if @page_size > 0
+          (@total_size / @page_size).ceil
+        else
+          @start_offset == 0 ? 1 : 2
+        end
+      end
+
+      def total_size
+        @total_size
+      end
+
+      def previous_page
+        PREVIOUS_COND_FUNCTION.call(
+          self,
+          lambda { |_| nil },
+          lambda { |pager| 
+            Pager.new(
+              NEGATIVE_FUNCTION.call(start_offset - page_size),
+              page_size,
+              total_size
+            )
+          }
+        )
+      end
+
+      def next_page
+        NEXT_COND_FUNCTION.call(
+          self,
+          lambda { |_| nil },
+          lambda { |pager| 
+            Pager.new(
+              NEGATIVE_FUNCTION.call(start_offset + page_size),
+              page_size,
+              total_size
+            )
+          }
+        )
+      end
+    end
+  end
+end

data/app/openbel/api/middleware/auth.rb

@@ -0,0 +1,112 @@
+require 'base64'
+require 'sinatra/base'
+require 'jwt'
+
+module OpenBEL
+  module JWTMiddleware
+
+    def self.encode(payload, secret)
+      ::JWT.encode(payload, secret, 'HS256')
+    end
+
+    def self.decode(token, secret, verify, options)
+      ::JWT.decode(token, secret, verify, options)
+    end
+
+    def self.check_cookie(env)
+      cookie_hdr = env['HTTP_COOKIE']
+      auth_hdr = env['HTTP_AUTHORIZATION']
+      if cookie_hdr.nil? and auth_hdr.nil?
+        raise 'missing authorization cookie/header'
+      end
+
+      if not cookie_hdr.nil?
+        cookies = cookie_hdr.split('; ')
+        selected = cookies.select {|x| x.start_with?('jwt=') }
+        if selected.size > 0
+          tokens = selected[0].split('=')
+          if tokens.size > 1
+            token = tokens[1]
+          end
+        end
+        if token.nil?
+          raise 'missing authorization cookie'
+        end
+      end
+
+      if not auth_hdr.nil?
+        tokens = auth_hdr.split('Bearer ')
+        if tokens.size == 2
+          token = tokens[1]
+        end
+        if token.nil?
+          raise 'missing authorization header'
+        end
+      end
+
+      secret = OpenBEL::Settings[:auth][:secret]
+      secret = Base64.decode64(secret)
+      # whether we should verify the token
+      verify = true
+      # JWT options passed to decode
+      options = {}
+
+      begin
+        decoded_token = decode(token, secret, verify, options)
+      rescue ::JWT::VerificationError => ve
+        raise 'invalid authorization token'
+      rescue ::JWT::DecodeError => je
+        puts je.inspect
+        raise 'malformed authorization token'
+      end
+      env['jwt.header'] = decoded_token.last unless decoded_token.nil?
+      env['jwt.payload'] = decoded_token.first unless decoded_token.nil?
+
+      exp = env['jwt.payload']['exp']
+      now = Time.now.to_i
+      if now > exp
+        raise 'token expired'
+      end
+
+      env['email'] = env['jwt.payload']['email']
+    end
+
+    class Authentication
+      def initialize(app, opts = {})
+        @app          = app
+        @paths       = opts.fetch(:paths, [])
+      end
+
+      def call(env)
+        check = false
+        if @paths.size == 0
+          # w/out paths, always check for token
+          check = true
+        else
+          path = env['PATH_INFO']
+          # w/ paths, only check for token iff matched
+          if @paths.any? {|x| path.start_with?(x)}
+            check = true
+          end
+        end
+
+        if check
+          begin
+            JWTMiddleware.check_cookie(env)
+          rescue Exception => e
+            return _401(e.message)
+          end
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def _401(message)
+        hdrs = {'Content-Type' => 'application/json'}
+        msg = {error: message }
+        [401, hdrs, [msg.to_json]]
+      end
+    end
+  end
+end

data/app/openbel/api/resources/adapters/basic_json.rb

@@ -0,0 +1,52 @@
+module Oat
+  module Adapters
+    class BasicJson < Oat::Adapter
+      def link(rel, opts = {})
+        # no-op to maintain interface compatibility with hypermedia adapters
+      end
+
+			def link(rel, opts = {})
+        if opts.is_a?(Array)
+          data[:_links][rel] = opts.select { |link_obj| link_obj.include?(:href) }
+        else
+          data[:_links][rel] = opts if opts[:href]
+        end
+      end
+
+      def properties(&block)
+        data.merge! yield_props(&block)
+      end
+
+      def property(key, value)
+        data[key] = value
+      end
+
+      alias_method :meta, :property
+
+      def rel(rels)
+        # no-op to maintain interface compatibility with the Siren adapter
+      end
+
+      def entity(name, obj, serializer_class = nil, context_options = {}, &block)
+        entity_serializer = serializer_from_block_or_class(obj, serializer_class, context_options, &block)
+        data[entity_name(name)] = entity_serializer ? entity_serializer.to_hash : nil
+      end
+
+      def entities(name, collection, serializer_class = nil, context_options = {}, &block)
+        data[entity_name(name)] = collection.map do |obj|
+          entity_serializer = serializer_from_block_or_class(obj, serializer_class, context_options, &block)
+          entity_serializer ? entity_serializer.to_hash : nil
+        end
+      end
+      alias_method :collection, :entities
+
+      def entity_name(name)
+        # entity name may be an array, but HAL only uses the first
+        name.respond_to?(:first) ? name.first : name
+      end
+
+      private :entity_name
+
+    end
+  end
+end

data/app/openbel/api/resources/annotation.rb

@@ -0,0 +1,141 @@
+require_relative 'base'
+
+module OpenBEL
+  module Resource
+    module Annotations
+
+      VOCABULARY_RDF = 'http://www.openbel.org/vocabulary/'
+
+      class AnnotationValueSearchResult < BEL::Resource::AnnotationValue
+
+        def match_text=(match_text)
+          @match_text = match_text
+        end
+
+        def match_text
+          @match_text
+        end
+      end
+
+      class AnnotationSerializer < BaseSerializer
+#        adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation
+          property :rdf_uri,    item.uri.to_s
+          property :name,       item.prefLabel
+          property :prefix,     item.prefix
+          property :domain,     item.domain
+        end
+      end
+
+      class AnnotationResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation
+          property :annotation, item
+          link     :self,       link_self(item[:prefix])
+        end
+
+        private
+
+        def link_self(id)
+          {
+            :type => :annotation,
+            :href => "#{base_url}/api/annotations/#{id}"
+          }
+        end
+
+        def link_collection
+          {
+            :type => :annotation_collection,
+            :href => "#{base_url}/api/annotations"
+          }
+        end
+      end
+
+      class AnnotationCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation_collection
+          property :annotation_collection, item
+          link     :self,                  link_self
+          link     :start,                 link_start
+        end
+
+        private
+
+        def link_self
+          {
+            :type => :annotation_collection,
+            :href => "#{base_url}/api/annotations"
+          }
+        end
+
+        def link_start
+          {
+            :type => :start,
+            :href => "#{base_url}/api/annotations/values"
+          }
+        end
+      end
+
+      class AnnotationValueSerializer < BaseSerializer
+        #adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation_value
+          property :rdf_uri,         item.uri.to_s
+          property :type,            [item.type].flatten.map(&:to_s)
+          property :identifier,      item.identifier
+          property :name,            item.prefLabel
+          entity   :annotation,      item.annotation, AnnotationSerializer
+
+          # Support inclusion of the matched text when annotation values are filtered by
+          # a full-text search.
+          if item.match_text
+            property :match_text,    item.match_text
+          end
+
+          setup(item)
+          link     :self,            link_self
+          link     :collection,      link_annotation
+        end
+
+        private
+
+        def setup(item)
+          @annotation_id, @annotation_value_id = URI(item.uri).path.split('/')[3..-1]
+        end
+
+        def link_self
+          {
+            :type => :annotation_value,
+            :href => "#{base_url}/api/annotations/#{@annotation_id}/values/#{@annotation_value_id}"
+          }
+        end
+
+        def link_annotation
+          {
+            :type => :annotation,
+            :href => "#{base_url}/api/annotations/#{@annotation_id}"
+          }
+        end
+      end
+
+      class AnnotationValueResourceSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation_value
+          property :annotation_value, item
+        end
+      end
+
+      class AnnotationValueCollectionSerializer < BaseSerializer
+        adapter Oat::Adapters::HAL
+        schema do
+          type     :annotation_value_collection
+          property :annotation_value_collection, item
+        end
+      end
+    end
+  end
+end