blobsterix 0.0.9

data/lib/blobsterix/helper/config_loader.rb

@@ -0,0 +1,33 @@
+module Blobsterix
+  module ConfigLoader
+    def load_blobsterix_config
+      require_storages
+      require_transformators
+      require_config
+    end
+
+    def require_config()
+      require Blobsterix.root.join("config.rb") if (File.exist?(Blobsterix.root.join("config.rb")))
+    end
+
+    def require_transformators()
+      trafo_dir = Blobsterix.root.join("transformators")
+      return if not File.exist?(trafo_dir)
+      Dir.entries(trafo_dir).each{|dir|
+        if !File.directory? File.join(trafo_dir,dir) and !(dir =='.' || dir == '..')
+          require "#{File.join(trafo_dir,dir)}"
+        end
+      }
+    end
+
+    def require_storages()
+      storages_dir = Blobsterix.root.join("storages")
+      return if not File.exist?(storages_dir)
+      Dir.entries(storages_dir).each{|dir|
+        if !File.directory? File.join(storages_dir,dir) and !(dir =='.' || dir == '..')
+          require "#{File.join(storages_dir,dir)}"
+        end
+      }
+    end
+  end
+end

data/lib/blobsterix/helper/data_response.rb

@@ -0,0 +1,54 @@
+module Blobsterix
+  module Http
+    class DataResponse
+      attr_reader :meta, :with_data, :etag, :env
+
+      def initialize(_meta, _with_data=true, _etag=nil, _env = nil)
+        @meta = _meta
+        @with_data = _with_data
+        @etag = _etag
+        @env = _env
+      end
+
+      def call(xfile=false, allow_chunks=true)
+        if not meta.valid
+          Http.NotFound()
+        elsif xfile and etag != meta.etag
+          [200, meta.header.merge({"X-Sendfile" => meta.path}), ""]
+        elsif etag != meta.etag
+          if env != nil && meta.size > 30000 && allow_chunks
+            chunkresponse
+          else
+            [200, meta.header, (with_data ? meta.data : "")]
+          end
+        else
+          [304, meta.header, ""]
+        end
+      end
+
+      private
+        def chunkresponse
+          f = File.open(meta.path)
+          EM.next_tick do
+            send_chunk(f)
+          end
+          [200, meta.header.merge(Goliath::Response::CHUNKED_STREAM_HEADERS), (with_data ? Goliath::Response::STREAMING : "")]
+        end
+
+        def send_chunk(file)
+          dat = file.read(10000)
+          again = if dat != nil
+            env.chunked_stream_send(dat)
+            true
+          else
+            file.close
+            env.chunked_stream_close
+            false
+          end
+          EM.next_tick do
+            send_chunk(file)
+          end if again
+        end
+    end
+  end
+end

data/lib/blobsterix/helper/http.rb

@@ -0,0 +1,47 @@
+module Blobsterix
+  module Http
+    def self.renderer
+      @@renderer||=(Blobsterix.respond_to?(:env) && Blobsterix.env == :production) ? TemplateRenderer.new(binding) : ReloadTemplateRenderer.new(binding)
+    end
+    def self.error_object_binding(obj)
+      obj||={}
+      def obj.get_binding
+        binding
+      end
+      def obj.title
+        self[:title]
+      end
+      def obj.content
+        self[:content]
+      end
+      def obj.error_code
+        self[:error_code]
+      end
+      obj.get_binding
+    end
+    def self.NextApi(data="Not Found", content_type="txt")
+      [600, {"Content-Type" => MimeMagic.by_extension(content_type).type}, data]
+    end
+    def self.NotFound(data="Not Found", content_type="html")
+      [404, {"Content-Type" => MimeMagic.by_extension(content_type).type}, renderer.render("error_page", error_object_binding(:title=>"Not Found", :content=>data, :error_code => 404))]
+    end
+    def self.ServerError(data="Server Error", content_type="html")
+      [500, {"Content-Type" => MimeMagic.by_extension(content_type).type}, renderer.render("error_page", error_object_binding(:title=>"Server Error", :content=>data, :error_code => 500))]
+    end
+    def self.NotAllowed(data="Not Allowed", content_type="html")
+      [403, {"Content-Type" => MimeMagic.by_extension(content_type).type}, renderer.render("error_page", error_object_binding(:title=>"Not Allowed", :content=>data, :error_code => 403))]
+    end
+    def self.NotAuthorized(data="Not Authorized", content_type="html")
+      [401, {"Content-Type" => MimeMagic.by_extension(content_type).type}, renderer.render("error_page", error_object_binding(:title=>"Not Authorized", :content=>data, :error_code => 401))]
+    end
+    def self.OK(data="", content_type="txt")
+      [200, {"Content-Type" => MimeMagic.by_extension(content_type).type}, data]
+    end
+    def self.Response(status_code=200, data="", content_type="txt")
+      [status_code, {"Content-Type" => MimeMagic.by_extension(content_type).type}, data]
+    end
+    def self.OK_no_data(data="", content_type="txt")
+      [204, {}, ""]
+    end
+  end
+end

data/lib/blobsterix/helper/logable.rb

@@ -0,0 +1,11 @@
+module Blobsterix
+  module Logable
+    def logger
+      @logger ||= Blobsterix.logger
+    end
+
+    def logger=(_logger)
+      @logger=_logger
+    end
+  end
+end

data/lib/blobsterix/helper/murmur.rb

@@ -0,0 +1,137 @@
+#only usefull to hash strings
+class Murmur
+  def self.force_overflow_signed(i)
+    force_overflow_unsigned(i + 2**31) - 2**31
+  end
+
+  def self.force_overflow_unsigned_16(i)
+    i % 2**16   # or equivalently: i & 0xffffffff
+  end
+
+  def self.force_overflow_unsigned(i)
+    i % 2**32   # or equivalently: i & 0xffffffff
+  end
+
+  def self.force_overflow_unsigned_64(i)
+    i % 2**64   # or equivalently: i & 0xffffffff
+  end
+
+  #64bit processors
+  def self.Hash64A (key)
+    len = key.size
+    seed = 11
+
+    m = 0xc6a4a7935bd1e995
+    r = 47
+
+    h = seed ^ len;
+
+    data = String.new(key)
+
+    while len >= 8
+      k = data.slice!(0..7).unpack("Q")[0]
+
+      k = force_overflow_unsigned_64(k * m)
+      k ^= k >> r
+      k = force_overflow_unsigned_64(k * m)
+
+      h ^= k;
+      h = force_overflow_unsigned_64(h * m)
+
+      len-=8
+    end
+
+    h ^= data.slice(6).to_i << 48 if len == 7
+    h ^= data.slice(5).to_i << 40 if len >= 6
+    h ^= data.slice(4).to_i << 32 if len >= 5
+    h ^= data.slice(3).to_i << 24 if len >= 4
+    h ^= data.slice(2).to_i << 16 if len >= 3
+    h ^= data.slice(1).to_i << 8 if len >= 2
+    h ^= data.slice(0).to_i if len >= 1
+
+    h = force_overflow_unsigned_64(h * m) if len
+
+    h ^= h >> r
+    h = force_overflow_unsigned_64(h * m)
+    h ^= h >> r
+
+    h
+  end
+
+  def self.get_num(num)
+    return num if num.class == Fixnum
+    num.to_s.unpack("C")[0]
+  end
+
+  #32bit processors
+  def self.Hash64B(key)
+    len = key.size
+    seed = 11
+
+    m = 0x5bd1e995 #1540483477
+    r = 24
+
+    h1 = seed ^ len
+    h2 = 0
+
+    data = String.new(key)#.force_encoding('ASCII-8BIT')
+    
+    while len >= 8
+      k1 = data.slice!(0..3).unpack("I")[0]
+
+      k1 = force_overflow_unsigned(k1 * m)
+      k1 ^= k1 >> r
+
+      k1 = force_overflow_unsigned(k1 * m)
+      h1 = force_overflow_unsigned(h1 * m)
+
+      h1 ^= k1
+      len -= 4
+
+
+      k2 = data.slice!(0..3).unpack("I")[0]
+
+      k2 = force_overflow_unsigned(k2 * m)
+      k2 ^= k2 >> r
+
+      k2 = force_overflow_unsigned(k2 * m)
+      h2 = force_overflow_unsigned(h2 * m)
+
+      h2 ^= k2
+      len -= 4
+    end
+
+    if len >= 4
+      k1 = data.slice!(0..3).unpack("I")[0]
+
+      k1 = force_overflow_unsigned(k1 * m)
+      k1 ^= k1 >> r
+
+      k1 = force_overflow_unsigned(k1 * m)
+      h1 = force_overflow_unsigned(h1 * m)
+
+      h1 ^= k1
+      len -= 4
+    end
+
+    h2 ^= (get_num(data[2]) << 16) if len == 3
+    h2 ^= (get_num(data[1]) << 8).to_i if len >= 2
+    h2 ^= (get_num(data[0])) if len >= 1
+
+    h2 = force_overflow_unsigned(h2 * m) if len > 0
+
+    h1 ^= h2 >> 18
+    h1 = force_overflow_unsigned(h1 * m)
+
+    h2 ^= h1 >> 22
+    h2 = force_overflow_unsigned(h2 * m)
+
+    h1 ^= h2 >> 17
+    h1 = force_overflow_unsigned(h1 * m)
+
+    h = h1
+    h = (h << 32) | h2
+
+    h
+  end
+end

data/lib/blobsterix/helper/status_info.rb

@@ -0,0 +1,42 @@
+module Blobsterix
+  module StatusInfo
+    def self.boot_up
+      @start_time=Time.now
+    end
+    boot_up
+    
+    def self.uptime
+      Time.now-@start_time
+    end
+    def self.cache_hit
+      @cache_hit||=0
+    end
+    def self.cache_hit=(obj)
+      @cache_hit=obj
+    end
+    def self.cache_miss
+      @cache_miss||=0
+    end
+    def self.cache_miss=(obj)
+      @cache_miss=obj
+    end
+    def self.cache_error
+      @cache_error||=0
+    end
+    def self.cache_error=(obj)
+      @cache_error=obj
+    end
+    def self.cache_access
+      @cache_access||=0
+    end
+    def self.cache_access=(obj)
+      @cache_access=obj
+    end
+    def self.connections
+      @connections||=0
+    end
+    def self.connections=(obj)
+      @connections=obj
+    end
+  end
+end

data/lib/blobsterix/helper/template_renderer.rb

@@ -0,0 +1,39 @@
+module Blobsterix
+  class ReloadTemplateRenderer
+    def initialize(binding_)
+      @binding = binding_
+    end
+
+    def render(template_name, bind=nil)
+      TemplateRenderer.new(bind||@binding).render(template_name)
+    end
+  end
+
+  class TemplateRenderer
+    def initialize(controller_binding_)
+      @controller_binding=controller_binding_
+    end
+
+    def render(template_name, bind=nil)
+      template(template_name).result(bind||controller_binding)
+    end
+
+    private
+
+    def controller_binding
+      @controller_binding
+    end
+
+    def template(template_name)
+      begin
+        templates[template_name]||=::ERB.new(File.read(Blobsterix.root.join("views", "#{template_name}.erb")))
+      rescue Errno::ENOENT => e
+        templates[template_name]||=::ERB.new(File.read(Blobsterix.root_gem.join("templates/views", "#{template_name}.erb")))
+      end
+    end
+
+    def templates
+      @templates||={}
+    end
+  end
+end

data/lib/blobsterix/mimemagic/magic.rb

@@ -0,0 +1,138 @@
+# Mime type detection
+class MimeMagic
+  attr_reader :type, :mediatype, :subtype
+
+  # Mime type by type string
+  def initialize(type)
+    @type = type
+    @mediatype, @subtype = type.split('/', 2)
+  end
+
+  # Add custom mime type. Arguments:
+  # * <i>type</i>: Mime type
+  # * <i>options</i>: Options hash
+  #
+  # Option keys:
+  # * <i>:extensions</i>: String list or single string of file extensions
+  # * <i>:parents</i>: String list or single string of parent mime types
+  # * <i>:magic</i>: Mime magic specification
+  # * <i>:comment</i>: Comment string
+  def self.add(type, options)
+    extensions = [options[:extensions]].flatten.compact
+    TYPES[type] = [extensions,
+                  [options[:parents]].flatten.compact,
+                  options[:comment]]
+    extensions.each {|ext| EXTENSIONS[ext] = type }
+    MAGIC.unshift [type, options[:magic]] if options[:magic]
+  end
+
+  # Removes a mime type from the dictionary.  You might want to do this if
+  # you're seeing impossible conflicts (for instance, application/x-gmc-link).
+  # * <i>type</i>: The mime type to remove.  All associated extensions and magic are removed too.
+  def self.remove(type)
+    EXTENSIONS.delete_if {|ext, t| t == type }
+    MAGIC.delete_if {|t, m| t == type }
+    TYPES.delete(type)
+  end
+
+  # Returns true if type is a text format
+  def text?; mediatype == 'text' || child_of?('text/plain'); end
+
+  # Mediatype shortcuts
+  def image?; mediatype == 'image'; end
+  def audio?; mediatype == 'audio'; end
+  def video?; mediatype == 'video'; end
+
+  # Returns true if type is child of parent type
+  def child_of?(parent)
+    MimeMagic.child?(type, parent)
+  end
+
+  # Get string list of file extensions
+  def extensions
+    TYPES.key?(type) ? TYPES[type][0] : []
+  end
+
+  # Get mime comment
+  def comment
+    (TYPES.key?(type) ? TYPES[type][2] : nil).to_s
+  end
+
+  # Lookup mime type by file extension
+  def self.by_extension(ext)
+    ext = ext.to_s.downcase
+    mime = ext[0..0] == '.' ? EXTENSIONS[ext[1..-1]] : EXTENSIONS[ext]
+    mime && new(mime)
+  end
+
+  # Lookup mime type by filename
+  def self.by_path(path)
+    by_extension(File.extname(path))
+  end
+
+  # Lookup mime type by magic content analysis.
+  # This is a slow operation.
+  def self.by_magic(io)
+    mime =
+      unless io.respond_to?(:seek) && io.respond_to?(:read)
+        str = io.respond_to?(:read) ? io.read : io.to_s
+        str = str.force_encoding(Encoding::BINARY) if str.respond_to? :force_encoding
+        MAGIC.find {|type, matches| magic_match_str(str, matches) }
+      else
+        io.binmode
+        io.set_encoding(Encoding::BINARY) if io.respond_to?(:set_encoding)
+        MAGIC.find {|type, matches| magic_match_io(io, matches) }
+      end
+    mime && new(mime[0])
+  end
+
+  # Return type as string
+  def to_s
+    type
+  end
+
+  # Allow comparison with string
+  def eql?(other)
+    type == other.to_s
+  end
+
+  def hash
+    type.hash
+  end
+
+  alias == eql?
+
+  def self.child?(child, parent)
+    child == parent || TYPES.key?(child) && TYPES[child][1].any? {|p| child?(p, parent) }
+  end
+
+  def self.magic_match_io(io, matches)
+    matches.any? do |offset, value, children|
+      match =
+        if Range === offset
+          io.seek(offset.begin)
+          x = io.read(offset.end - offset.begin + value.bytesize)
+          x && x.include?(value)
+        else
+          io.seek(offset)
+          io.read(value.bytesize) == value
+        end
+      match && (!children || magic_match_io(io, children))
+    end
+  end
+
+  def self.magic_match_str(str, matches)
+    matches.any? do |offset, value, children|
+      match =
+        if Range === offset
+          x = str[offset.begin, offset.end - offset.begin + value.bytesize]
+          x && x.include?(value)
+        else
+          str[offset, value.bytesize] == value
+        end
+      match && (!children || magic_match_str(str, children))
+    end
+  end
+
+  private_class_method :magic_match_io, :magic_match_str
+end