blix-rest 0.1.30 → 0.7.2

data/lib/blix/rest/cucumber/world.rb

@@ -4,7 +4,7 @@
 class RestWorld
   # the entry point to the rack application to be tested
   def self.app
-    @_app ||= Rack::Builder.parse_file('config.ru').first
+    @_app ||= Rack::Builder.parse_file('config.ru')
   end
 
   # a dummy request to sent to the server
@@ -16,15 +16,16 @@ class RestWorld
   class Response
     def initialize(resp)
       @resp = resp
-      if @resp.header['Content-Type'] == 'application/json'
+      content_type = @resp.headers['Content-Type'] || @resp.headers['content-type']
+      if content_type == 'application/json'
         begin
-          @h = MultiJson.load(@resp.body) || {}
+          @h = MultiJson.load(body) || {}
         rescue Exception => e
-          puts 'INVALID RESPONSE BODY=>' + @resp.body
+          log 'INVALID RESPONSE BODY=>' + body
           raise
         end
       else
-        @h = { 'html' => @resp.body }
+        @h = { 'html' => body }
       end
 
       # get_ids_from_hash
@@ -35,7 +36,7 @@ class RestWorld
     end
 
     def body
-      @resp.body
+      [@resp.body].flatten.join('')
     end
 
     def data
@@ -51,7 +52,7 @@ class RestWorld
     end
 
     def header
-      @resp.header || {}
+      @resp.headers || {}
     end
 
     def content_type
@@ -93,10 +94,10 @@ class RestWorld
   end
 
   def explain
-    puts "request ==> #{@_verb} #{@_request}"
-    puts "cookies ==> #{cookies.join('; ')}" if cookies.length > 0
-    puts "body ==> #{@_body}" if @_body
-    puts "response ==> #{@_response.inspect}"
+    log "request ==> #{@_verb} #{@_request}"
+    log "cookies ==> #{cookies.join('; ')}" if cookies.length > 0
+    log "body ==> #{@_body}" if @_body
+    log "response ==> #{@_response.inspect}"
   end
 
   def before_parse_path(path); end
@@ -217,7 +218,7 @@ class RestWorld
     @_response = Response.new(raw_response)
     # add cookies to the cookie jar.
     #unless @_current_user=="guest"
-    if cookie = @_response.header["Set-Cookie"]
+    if cookie = @_response.header["Set-Cookie"] || @_response.header["set-cookie"]
       parts = cookie.split(';')
       cookies << parts[0].strip
     end

data/lib/blix/rest/format_parser.rb

@@ -72,16 +72,16 @@ module Blix::Rest
     def format_response(value, response)
       if value.is_a?(RawJsonString)
         response.content = if _options[:nodata]
-                             value.to_s
+                             [value.to_s]
                            else
-                             "{\"data\":#{value}}"
+                             ["{\"data\":#{value}}"]
                            end
       else
         begin
           response.content = if _options[:nodata]
-                               MultiJson.dump(value)
+                               [MultiJson.dump(value)]
                              else
-                               MultiJson.dump('data' => value)
+                               [MultiJson.dump('data' => value)]
                            end
         rescue Exception => e
           ::Blix::Rest.logger << e.to_s
@@ -107,7 +107,8 @@ module Blix::Rest
     end
 
     def format_response(value, response)
-      response.content = value.to_s
+      value = [value.to_s] unless value.respond_to?(:each) ||  value.respond_to?(:call)
+      response.content = value
     end
 
   end
@@ -121,8 +122,8 @@ module Blix::Rest
 
     def set_default_headers(headers)
       headers[CACHE_CONTROL] = CACHE_NO_STORE
-      headers[PRAGMA]       = NO_CACHE
-      headers[CONTENT_TYPE] = CONTENT_TYPE_XML
+      headers[PRAGMA]        = NO_CACHE
+      headers[CONTENT_TYPE]  = CONTENT_TYPE_XML
     end
 
     def format_error(message)
@@ -130,7 +131,7 @@ module Blix::Rest
     end
 
     def format_response(value, response)
-      response.content = value.to_s # FIXME
+      response.content = [value.to_s]
     end
 
   end
@@ -144,8 +145,14 @@ module Blix::Rest
 
     def set_default_headers(headers)
       headers[CACHE_CONTROL] = CACHE_NO_STORE
-      headers[PRAGMA]       = NO_CACHE
-      headers[CONTENT_TYPE] = CONTENT_TYPE_HTML
+      headers[PRAGMA]        = NO_CACHE
+      headers[CONTENT_TYPE]  = CONTENT_TYPE_HTML
+      # headers['X-Frame-Options']        =  'SAMEORIGIN'
+      # headers['X-XSS-Protection']       =  '1; mode=block'
+      # headers['X-Content-Type-Options'] =  'nosniff'
+      # headers['X-Download-Options']     =  'noopen'
+      # headers['X-Permitted-Cross-Domain-Policies'] =  'none'
+      # headers['Referrer-Policy']        =  'strict-origin-when-cross-origin'
     end
 
     def format_error(message)
@@ -160,7 +167,7 @@ module Blix::Rest
     end
 
     def format_response(value, response)
-      response.content = value.to_s
+      response.content = [value.to_s]
     end
 
   end

data/lib/blix/rest/redis_cache.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'redis'
+require_relative 'cache'
+require_relative 'string_hash'
+#
+#  options:
+#     :expire_secs           - how long store should save data.
+#     :reset_expire_on_get   - start the expire timer again on read.
+
+module Blix
+  module Rest
+    class RedisCache < Cache
+
+      STORE_PREFIX = 'blixcache'
+
+      #---------------------------------------------------------------------------
+
+      # clear all data from the cache
+      def clear
+        reset
+      end
+
+      # retrieve data from the cache
+      def get(id)
+        key = _key(id)
+        str = redis.get(key)
+        data = str && begin
+                        _decode(str)
+                      rescue StandardError
+                         redis.del( key)
+                         nil
+                      end
+        redis.expire(key, _opts[:expire_secs]) if data && _opts[:reset_expire_on_get] && _opts.key?(:expire_secs)
+        data
+      end
+
+      # set data in the cache
+      def set(id, data)
+        params = {}
+        params[:ex] = _opts[:expire_secs] if _opts.key?(:expire_secs)
+        redis.set(_key(id), _encode(data), **params)
+        data
+      end
+
+      #  is key present in the cache
+      def key?(id)
+        redis.get(_key(id)) != nil
+      end
+
+      def delete(id)
+        redis.del(_key(id)) > 0
+      end
+
+      #---------------------------------------------------------------------------
+
+      def _key(name)
+        _prefix + name
+      end
+
+      def _opts
+        @_opts ||= begin
+          o = ::Blix::Rest::StringHash.new
+          o[:prefix] = STORE_PREFIX
+          o.merge!(params)
+          o
+        end
+      end
+
+      def _prefix
+        @_prefix ||= _opts[:prefix]
+      end
+
+      # remove all sessions from the store
+      def reset(name = nil)
+        keys = _all_keys(name)
+        redis.del(*keys) unless keys.empty?
+      end
+
+      def _all_keys(name = nil)
+        redis.keys("#{_prefix}#{name}*") || []
+      end
+
+      # the redis session store
+      def redis
+        @redis ||= begin
+          r = Redis.new
+          begin
+            r.ping
+          rescue Exception => e
+            Blix::Rest.logger.error "cannot reach redis server:#{e}"
+            raise
+          end
+          r
+        end
+      end
+
+      # the number of sessions in the store
+      def length
+        _all_keys.length
+      end
+
+      # delete expired sessions from the store. this should be handled
+      # automatically by redis if the ttl is set on save correctly
+      def cleanup(opts = nil); end
+
+      def _encode(data)
+        Marshal.dump(data)
+      end
+
+      def _decode(msg)
+        Marshal.load(msg)
+      end
+
+      def get_expiry_time
+        if expire = _opts[:expire_secs] || _opts['expire_secs']
+          Time.now - expire
+        end
+      end
+
+      def get_expiry_secs
+        _opts[:expire_secs] || _opts['expire_secs']
+      end
+
+    end
+  end
+end

data/lib/blix/rest/request_mapper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'thread'
 
 module Blix::Rest
   class RequestMapperError < StandardError; end
@@ -7,6 +8,8 @@ module Blix::Rest
   # these routes and return an associated block and parameters.
   class RequestMapper
 
+    @@mutex = Mutex.new
+
     WILD_PLACEHOLDER = '/'
     PATH_SEP         = '/'
     STAR_PLACEHOLDER = '*'
@@ -52,6 +55,7 @@ module Blix::Rest
 
     class << self
 
+      # the root always starts with '/' and finishes with '/'
       def set_path_root(root)
         root = root.to_s
         root = '/' + root if root[0, 1] != '/'
@@ -64,19 +68,30 @@ module Blix::Rest
         @path_root || '/'
       end
 
-      attr_reader :path_root_length
+      def path_root_length
+        @path_root_length.to_i
+      end
 
       def full_path(path)
         path = path[1..-1] if path[0, 1] == '/'
         path_root + path
       end
 
+      # ensure that absolute path is the  full path
+      def ensure_full_path(path)
+        if path[0, 1] == '/' && (path_root_length>0) && path[0, path_root_length] != path_root[0, path_root_length]
+          path = path_root + path[1..-1]
+        end
+        path
+      end
+
       def locations
         @locations ||= Hash.new { |h, k| h[k] = [] }
       end
 
       def table
-        @table ||= compile
+        # compile the table in one thread only.
+        @table ||= @@mutex.synchronize{@table ||= compile}
       end
 
       def dump
@@ -147,6 +162,7 @@ module Blix::Rest
         path = path[1..-1] if path[0, 1] == PATH_SEP
         RequestMapper.locations[verb] << [verb, path, opts, blk]
         @table = nil # force recompile
+        true
       end
 
       # match a given path to  declared route.
@@ -212,12 +228,12 @@ module Blix::Rest
             # .. if there is a wildpath foloowing then fine ..
             # .. otherwise an error !
 
-            if idx == limit # the last section of request
+            if idx == limit # the last section of path
               if current.blk
                 return [current.blk, parameters, current.opts]
               elsif (havewild = current[STAR_PLACEHOLDER])
                 parameters[havewild.parameter.to_s] = '/'
-                return [havewild.blk, parameters, havewild.opts]
+                return [havewild.blk, parameters, havewild.opts, true]
               else
                 return [nil, {}, nil]
               end
@@ -250,7 +266,7 @@ module Blix::Rest
                   return [current.blk, parameters, current.opts]
                 elsif (havewild = current[STAR_PLACEHOLDER])
                   parameters[havewild.parameter.to_s] = '/'
-                  return [havewild.blk, parameters, havewild.opts]
+                  return [havewild.blk, parameters, havewild.opts, true]
                 else
                   return [nil, {}, nil]
                 end
@@ -268,7 +284,7 @@ module Blix::Rest
                   parameters['format'] = wildformat[1..-1].to_sym
                 end
                 parameters[current.parameter.to_s] = wildpath
-                return [current.blk, parameters, current.opts]
+                return [current.blk, parameters, current.opts, true]
               else
                 return [nil, {}, nil]
               end

data/lib/blix/rest/response.rb

@@ -12,13 +12,13 @@ module Blix::Rest
 
     def initialize
       @status  = 200
-      @headers  = {}
+      @headers  = Rack::Headers.new
       @content = nil
     end
 
     def set(status,content=nil,headers=nil)
       @status = status if status
-      @content = String.new(content) if content
+      @content = [String.new(content)] if content
       @headers.merge!(headers) if headers
     end
 

data/lib/blix/rest/server.rb

@@ -17,8 +17,23 @@ module Blix::Rest
       @_options = opts
     end
 
+    # options passed to the server
+    def _options
+      @_options
+    end
+
+
+    # the object serving as a cache
     def _cache
-      @_cache ||= {}
+      @_cache ||= begin
+        obj = _options[:cache] || _options['cache']
+        if obj
+          raise "cache must be a subclass of Blix::Rest::Cache" unless obj.is_a?(Cache)
+          obj
+        else
+          MemoryCache.new
+        end
+      end
     end
 
     def extract_parsers_from_options(opts)
@@ -34,7 +49,6 @@ module Blix::Rest
     def set_custom_headers(format, headers)
       parser = get_parser(format)
       raise "parser not found for custom headers format=>#{format}" unless parser
-
       parser.__custom_headers = headers
     end
 
@@ -54,6 +68,7 @@ module Blix::Rest
       parser._types.each { |t| @_mime_types[t.downcase] = parser } # register each of the mime types
     end
 
+    # retrieve parameters from the http request
     def retrieve_params(env)
       post_params = {}
       body        = ''
@@ -104,6 +119,7 @@ module Blix::Rest
       end
     end
 
+    # determine standard format from http mime type
     def get_format_from_mime(mime)
       case mime
       when 'application/json' then :json
@@ -138,20 +154,24 @@ module Blix::Rest
       parser
     end
 
+    # the call function is the interface with the rack framework
     def call(env)
       req = Rack::Request.new(env)
 
-      verb            = env['REQUEST_METHOD']
-      path            = req.path
+      verb  = env['REQUEST_METHOD']
+      path  = req.path
+      path  = CGI.unescape(path).gsub('+',' ') unless _options[:unescape] == false
 
-      blk, path_params, options = RequestMapper.match(verb, path)
+      blk, path_params, options, is_wild = RequestMapper.match(verb, path)
+
+      match_all = RequestMapper.match('ALL', path) unless blk && !is_wild
+      blk, path_params, options = match_all if match_all && match_all[0] # override
 
-      blk, path_params, options = RequestMapper.match('ALL', path) unless blk
 
       default_format = options && options[:default] && options[:default].to_sym
       force_format = options && options[:force] && options[:force].to_sym
-      do_cache = options && options[:cache]
-      clear_cache = options && options[:cache_reset]
+      do_cache     = options && options[:cache] && !Blix::Rest.cache_disabled
+      clear_cache  = options && options[:cache_reset]
 
       query_format = options && options[:query] && req.GET['format'] && req.GET['format'].to_sym
 
@@ -159,39 +179,49 @@ module Blix::Rest
 
       parser = get_parser(force_format || format)
 
-      return [406, {}, ["Invalid Format: #{format}"]] unless parser
+      unless parser
+        if blk
+          return [406, {}, ["Invalid Format: #{format}"]]
+        else
+          return [404, {}, ["Invalid Url"]]
+        end
+      end
 
       parser._options = options
 
       # check for cached response end return with cached response if found.
       #
-      if do_cache && _cache["#{verb}|#{format}|#{path}"]
-        response = _cache["#{verb}|#{format}|#{path}"]
-        return [response.status, response.headers.merge('X-Blix-Cache' => 'cached'), [response.content]]
+      if do_cache && ( response = _cache["#{verb}|#{format}|#{path}"] )
+        return [response.status, response.headers.merge('x-blix-cache' => 'cached'), response.content]
       end
 
       response = Response.new
 
-      if parser.__custom_headers
-        response.headers.merge! parser.__custom_headers
-      else
-        parser.set_default_headers(response.headers)
-      end
-
       if blk
 
         begin
           params = env['params']
-          value  = blk.call(path_params, params, req, format, response, @_options)
+          context = Context.new(path_params, params, req, format, response, verb, self)
+          value  = blk.call(context)
         rescue ServiceError => e
+          set_default_headers(parser,response)
           response.set(e.status, parser.format_error(e.message), e.headers)
+        rescue RawResponse => e
+          value = e.content
+          value = [value.to_s] unless value.respond_to?(:each) ||  value.respond_to?(:call)
+          response.status  = e.status if e.status
+          response.content = value
+          response.headers.merge!(e.headers) if e.headers
         rescue AuthorizationError => e
+          set_default_headers(parser,response)
           response.set(401, parser.format_error(e.message), AUTH_HEADER => "#{e.type} realm=\"#{e.realm}\", charset=\"UTF-8\"")
         rescue Exception => e
+          set_default_headers(parser,response)
           response.set(500, parser.format_error('internal error'))
           ::Blix::Rest.logger <<  "----------------------------\n#{$!}\n----------------------------"
           ::Blix::Rest.logger <<  "----------------------------\n#{$@}\n----------------------------"
         else # no error
+          set_default_headers(parser,response)
           parser.format_response(value, response)
           # cache response if requested
           _cache.clear if clear_cache
@@ -199,9 +229,19 @@ module Blix::Rest
         end
 
       else
+        set_default_headers(parser,response)
         response.set(404, parser.format_error('Invalid Url'))
       end
-      [response.status, response.headers, [response.content]]
+
+      [response.status.to_i, response.headers, response.content]
+    end
+
+    def set_default_headers(parser,response)
+      if parser.__custom_headers
+        response.headers.merge! parser.__custom_headers
+      else
+        parser.set_default_headers(response.headers)
+      end
     end
 
   end

data/lib/blix/rest/version.rb

@@ -1,5 +1,5 @@
 module Blix
   module Rest
-    VERSION = "0.1.30"
+    VERSION = "0.7.2"
   end
 end

data/lib/blix/rest.rb

@@ -1,6 +1,8 @@
 require 'base64'
 require 'logger'
 require 'time'
+require 'cgi'
+require 'rack'
 
 module Blix
   module Rest
@@ -8,14 +10,14 @@ module Blix
     # EXPIRED_TOKEN_MESSAGE = 'token expired'
     # INVALID_TOKEN_MESSAGE = 'invalid token'
 
-    CONTENT_TYPE      = 'Content-Type'.freeze
+    CONTENT_TYPE      = 'content-type'.freeze
     CONTENT_TYPE_JSON = 'application/json'.freeze
     CONTENT_TYPE_HTML = 'text/html; charset=utf-8'.freeze
     CONTENT_TYPE_XML  = 'application/xml'.freeze
-    AUTH_HEADER       = 'WWW-Authenticate'.freeze
-    CACHE_CONTROL     = 'Cache-Control'.freeze
+    AUTH_HEADER       = 'www-authenticate'.freeze
+    CACHE_CONTROL     = 'cache-control'.freeze
     CACHE_NO_STORE    = 'no-store'.freeze
-    PRAGMA            = 'Pragma'.freeze
+    PRAGMA            = 'pragma'.freeze
     NO_CACHE          = 'no-cache'.freeze
     URL_ENCODED       = %r{^application/x-www-form-urlencoded}.freeze
     JSON_ENCODED      = %r{^application/json}.freeze # NOTE: "text/json" and "text/javascript" are deprecated forms
@@ -43,6 +45,14 @@ module Blix
       @_logger = val
     end
 
+    def self.cache_disabled
+      @_cache_disabled
+    end
+
+    def self.disable_cache
+      @_cache_disabled = true
+    end
+
     def self.logger
       @_logger ||= begin
         l = Logger.new(STDOUT)
@@ -67,13 +77,10 @@ module Blix
     end
 
     # interpret payload string as json
-    class RawJsonString
-      def initialize(str)
-        @str = str
-      end
+    class RawJsonString < String
 
       def as_json(*_a)
-        @str
+        self
       end
 
       def to_json(*a)
@@ -94,6 +101,19 @@ module Blix
       end
     end
 
+    class RawResponse < StandardError
+      attr_reader :status
+      attr_reader :headers
+      attr_reader :content
+
+      def initialize(message, status = nil, headers = nil)
+        super(message || "")
+        @status  = status
+        @headers = headers
+        @content = message
+      end
+    end
+
     class AuthorizationError < StandardError
       attr_reader :realm, :type
       def initialize(message=nil, realm=nil, type=nil)
@@ -128,6 +148,7 @@ require 'rack'
 require 'blix/rest/response'
 require 'blix/rest/format_parser'
 require 'blix/rest/request_mapper'
+require 'blix/rest/cache'
 require 'blix/rest/server'
 # require 'blix/rest/provider'
 require 'blix/rest/controller'

data/lib/blix/utils/redis_store.rb

@@ -36,7 +36,7 @@ module Blix
     def store_data(id, data)
       params = {}
       params[:ex] = _opts[:expire_secs] if _opts.key?(:expire_secs)
-      redis.set(_key(id), data, params)
+      redis.set(_key(id), data, **params)
       data
     end
 
@@ -89,7 +89,7 @@ module Blix
       params[:ex] = _opts[:expire_secs] if _opts.key?(:expire_secs)
       hash ||= {}
       hash['_last_access'] = Time.now
-      redis.set(_key(id), _encode(hash), params)
+      redis.set(_key(id), _encode(hash), **params)
       hash
     end