blix-rest 0.1.30 → 0.8.2

data/lib/blix/rest/controller.rb

@@ -3,6 +3,7 @@
 require 'base64'
 require 'erb'
 require 'securerandom'
+require 'digest'
 
 module Blix::Rest
   # base class for controllers. within your block handling a particular route you
@@ -21,8 +22,19 @@ module Blix::Rest
   #  to accept requests other thatn json then set :accept=>[:json,:html] as options in the route
   #    eg  post '/myform' :accept=>[:html]              # this will only accept html requests.
 
+  Context = Struct.new(
+    :path_params,
+    :params,
+    :req,
+    :format,
+    :response,
+    :method,
+    :server
+  )
+
   class Controller
 
+
     #--------------------------------------------------------------------------------------------------------
     # convenience methods
     #--------------------------------------------------------------------------------------------------------
@@ -35,6 +47,14 @@ module Blix::Rest
       @_server_options
     end
 
+    def server_cache
+      @_server_cache
+    end
+
+    def server_cache_get(key)
+      server_cache[key] ||= yield if block_given?
+    end
+
     def logger
       Blix::Rest.logger
     end
@@ -60,10 +80,21 @@ module Blix::Rest
       #      env['rack.input'].rewindreq.POST #env["body"]
     end
 
+    # ovverride the path method to return the internal path.
     def path
-      req.path
+      p = req.path
+      p = '/' + p if p[0, 1] != '/' # ensure a leading slash on path
+      idx = RequestMapper.path_root_length
+      if idx > 0
+        p = p[idx..-1] || '/'
+        p = '/' + p if p[0, 1] != '/' # ensure a leading slash on path
+        p
+      else
+        p
+      end
     end
 
+
     def form_hash
       StringHash.new(req.POST)
     end
@@ -113,7 +144,7 @@ module Blix::Rest
     end
 
     def path_for(path)
-      File.join(RequestMapper.path_root, path)
+      File.join(RequestMapper.path_root, path || '')
     end
 
     def url_for(path)
@@ -128,6 +159,26 @@ module Blix::Rest
       @_verb
     end
 
+    def method
+      @_method
+    end
+
+    def route_parameters
+      @_parameters
+    end
+
+    def route_params
+      @_parameters
+    end
+
+    def route_options
+      @_parameters
+    end
+
+    def response
+      @_response
+    end
+
     def method
       env['REQUEST_METHOD'].downcase
     end
@@ -147,7 +198,7 @@ module Blix::Rest
     end
 
     def redirect(path, status = 302)
-      raise ServiceError.new(nil, status, 'Location' => path)
+      raise ServiceError.new(nil, status, 'location' => RequestMapper.ensure_full_path(path))
     end
 
     alias redirect_to redirect
@@ -190,12 +241,36 @@ module Blix::Rest
       [login, password]
     end
 
+    # set the cors headers
+    def set_accept_cors(opts={})
+      origin  = opts[:origin] || env['HTTP_ORIGIN'] || '*'
+      origin  = origin.to_s
+      if method=='options'
+        methods = [opts[:methods] || []].to_a.flatten
+        max_age = opts[:max_age] || 86400
+        headers = [opts[:headers] || []].to_a.flatten
+        credentials = opts.key?(:credentials) ? !!opts[:credentials] : true
+        methods = [:get] if methods.empty?
+        methods = methods.map{|m| m.to_s.upcase}
+        headers = ['Content-Type'] if headers.empty?
+        max_age = max_age.to_i
+
+        add_headers 'Access-Control-Allow-Origin' => origin,
+           'Access-Control-Allow-Methods'=>methods.join(', '),
+           'Access-Control-Allow-Headers'=>headers,
+           'Access-Control-Max-Age'=>max_age, #86400,
+           'Access-Control-Allow-Credentials'=>'true'
+      else
+        add_headers 'Access-Control-Allow-Origin' => origin
+      end
+    end
+
     def set_status(value)
-      @_response.status = value
+      @_response.status = value.to_i
     end
 
     def add_headers(headers)
-      @_response.headers.merge!(headers)
+      @_response.headers.merge!(headers.map{|k,v| [k.to_s.downcase,v]}.to_h)
     end
 
     # the following is copied from Rack::Utils
@@ -231,6 +306,19 @@ module Blix::Rest
       raise ServiceError.new(message, status, headers)
     end
 
+    # send data to browser as attachment
+    def send_data(data, opts = {})
+      add_headers 'content-type'=> opts[:type] || 'application/octet-stream'
+      if opts[:filename]
+        add_headers 'content-disposition'=>'attachment;filename='+ opts[:filename]
+      elsif opts[:disposition] == 'attachment'
+        add_headers 'content-disposition'=>'attachment'
+      elsif opts[:disposition] == 'inline'
+        add_headers 'content-disposition'=>'inline'
+      end
+      raise RawResponse.new(data, opts[:status] || 200)
+    end
+
     def auth_error(*params)
       if params[0].kind_of?(String)
           message = params[0]
@@ -279,7 +367,7 @@ module Blix::Rest
       # else
       #   cookie_header = cookie_text
       # end
-      @_response.headers['Set-Cookie'] = @_cookies.values.join("\n")
+      @_response.headers['set-cookie'] = @_cookies.values.join("\n")
       value
     end
 
@@ -315,6 +403,16 @@ module Blix::Rest
       store_cookie(session_name, session_id, opts)
     end
 
+    # perform the before hooks.
+    def __before(*a)
+      self.class._do_before(self, *a)
+    end
+
+    # perform the after hooks
+    def __after(*a)
+      self.class._do_after(self, *a)
+    end
+
     #----------------------------------------------------------------------------------------------------------
     # template methods that can be overwritten
 
@@ -327,17 +425,32 @@ module Blix::Rest
       response
     end
 
+    def session_before(opts); end  # empty session before  hooh
+    def session_after; end  # empty session after hook
+
     #----------------------------------------------------------------------------------------------------------
 
-    def initialize(path_params, _params, req, format, verb, response, server_options)
-      @_req = req
-      @_env = req.env
+    def _setup(context, _verb, _path, _parameters)
+      @_context        = context
+      @_req            = context.req
+      @_env            = req.env
       @_query_params = StringHash.new(req.GET)
-      @_path_params  = StringHash.new(path_params)
-      @_format = format
-      @_verb = verb
-      @_response = response
-      @_server_options = server_options
+      @_path_params  = StringHash.new(context.path_params)
+      @_format         = context.format
+      @_verb           = _verb
+      @_response       = context.response
+      @_server_options = context.server._options
+      @_parameters     = _parameters
+      @_server_cache   = context.server._cache
+      @_method         = context.method
+    end
+
+    def to_s
+      "<#{self.class.to_s}:#{object_id}>"
+    end
+
+    def inspect
+      to_s
     end
 
     # do not cache templates in development mode
@@ -376,9 +489,9 @@ module Blix::Rest
         path        = opts[:path] || __erb_path || Controller.erb_root
 
         layout = layout_name && if no_template_cache
-                                  ERB.new(File.read(File.join(path, layout_name + '.html.erb')),nil,'-')
+                                  ERB.new(File.read(File.join(path, layout_name + '.html.erb')),:trim_mode=>'-')
                                 else
-                                  erb_templates[layout_name] ||= ERB.new(File.read(File.join(path, layout_name + '.html.erb')),nil,'-')
+                                  erb_templates[layout_name] ||= ERB.new(File.read(File.join(path, layout_name + '.html.erb')),:trim_mode=>'-')
         end
 
         begin
@@ -388,8 +501,8 @@ module Blix::Rest
             text
           end
         rescue Exception
-          puts $!
-          puts $@
+          ::Blix::Rest.logger <<  $!
+          ::Blix::Rest.logger <<  $@
           '*** TEMPLATE ERROR ***'
         end
       end
@@ -401,15 +514,15 @@ module Blix::Rest
         path        = opts[:erb_dir] || __erb_path || Controller.erb_root
 
         layout = layout_name && if no_template_cache
-                                  ERB.new(File.read(File.join(path, layout_name + '.html.erb')),nil,'-')
+                                  ERB.new(File.read(File.join(path, layout_name + '.html.erb')),:trim_mode=>'-')
                                 else
-                                  erb_templates[layout_name] ||= ERB.new(File.read(File.join(path, layout_name + '.html.erb')),nil,'-')
+                                  erb_templates[layout_name] ||= ERB.new(File.read(File.join(path, layout_name + '.html.erb')),:trim_mode=>'-')
         end
 
         erb = if no_template_cache
-                ERB.new(File.read(File.join(path, name + '.html.erb')),nil,'-')
+                ERB.new(File.read(File.join(path, name + '.html.erb')),:trim_mode=>'-')
               else
-                erb_templates[name] ||= ERB.new(File.read(File.join(path, name + '.html.erb')),nil,'-')
+                erb_templates[name] ||= ERB.new(File.read(File.join(path, name + '.html.erb')),:trim_mode=>'-')
         end
 
         begin
@@ -421,8 +534,8 @@ module Blix::Rest
             erb.result(bind)
           end
         rescue Exception
-          puts $!
-          puts $@
+          ::Blix::Rest.logger <<  $!
+          ::Blix::Rest.logger <<  $@
           '*** TEMPLATE ERROR ***'
         end
       end
@@ -447,19 +560,36 @@ module Blix::Rest
         raise ServiceError, 'invalid format for this request' unless accept.index format
       end
 
+      def _do_route_hook(route)
+        if @_route_hook
+          superclass._do_route_hook(route) if superclass.respond_to? :_do_route_hook
+          @_route_hook.call(route)
+        end
+      end
+
       def route(verb, path, opts = {}, &blk)
-        proc = lambda do |_path_params, _params, _req, _format, _response, server_options|
+        path = '/' + path unless path[0] == '/'
+        path = String.new(path)  # in case frozen.
+        route = Route.new(verb, path, opts)
+        _do_route_hook(route)
+        proc = lambda do |context|
           unless opts[:force] && (opts[:accept] == :*)
-            check_format(opts[:accept], _format)
+            check_format(opts[:accept], context.format)
           end
-          app = new(_path_params, _params, _req, _format, verb, _response, server_options)
+          app = new
+          app._setup(context, verb, path, opts)
           begin
+            app.session_before(opts)
             app.before(opts)
-            response = app.instance_eval( &blk )
+            app.__before
+            context.response = app.instance_eval( &blk )
           rescue
             raise
           ensure
-            app.after(opts, response)
+            app.__after
+            app.after(opts, context.response)
+            app.session_after
+            context.response
           end
         end
 
@@ -498,6 +628,49 @@ module Blix::Rest
         route 'OPTIONS', *a, &b
       end
 
+      def before_route(&b)
+        @_route_hook = b if b
+      end
+
+
+      def _before_hooks
+        @_before_hooks ||= {}
+      end
+
+      def _after_hooks
+        @_after_hooks ||= {}
+      end
+
+      def _do_before(ctx, *a)
+        superclass._do_before(ctx, *a) if superclass.respond_to? :_do_before
+        _before_hooks.each_value{ |h| ctx.instance_eval(&h) }
+      end
+
+      def _do_after(ctx, *a)
+        _after_hooks.each_value{ |h| ctx.instance_eval(&h) }
+        superclass._do_after(ctx, *a) if superclass.respond_to? :_do_after
+      end
+
+      # define a before hook for a controller. only one hook can be defined per
+      # controller in a single source file.
+      def before(&block)
+        if block
+          file = block.source_location[0]
+          warn("warning: before hook already defined in #{file}") if _before_hooks[file]
+          _before_hooks[file] = block
+        end
+      end
+
+      # define an after hook for a controller. only one hook can be defined per
+      # controller in a single source file.
+      def after(&block)
+        if block
+          file = block.source_location[0]
+          warn("warning: after hook already defined in #{file}") if _after_hooks[file]
+          _after_hooks[file] = block
+        end
+      end
+
     end
 
   end

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