porpoise 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b24e7c5e270d8c55573ea5d9224562ec9f30bca
+  data.tar.gz: 68a6fb51394b3ac03bd84b9d66f49e4350cd7f88
+SHA512:
+  metadata.gz: 87f66069bfeadce307935f5692a920fe845fcd709a8781b0d992dd1a3960e21b5c25ed59ee33c3c4970d6f2e55c100512193de386604a226bc2f1be5b30198da
+  data.tar.gz: 896cd60fa409cbda94f9158c69000ae5e11434594a24b35c86ebe6047c5685e389033da7c5d6e5371a08dffb7c7b351edeb69d6683abe29f5194bea70903890e

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.vscode/
+*.gem

data/Dockerfile

@@ -0,0 +1,15 @@
+# Build with docker build -t porpoise-app .
+# Run with docker run -it --rm -v "$PWD:/porpoise" porpoise-app
+
+FROM ruby:2.3.3
+RUN apt-get update -qq && apt-get install -y build-essential ruby-dev vim sqlite3
+
+ENV APP_HOME /porpoise
+RUN mkdir $APP_HOME
+WORKDIR $APP_HOME
+ADD . $APP_HOME
+
+RUN gem install rake -v=10.5.0
+RUN bundle install
+
+CMD /bin/bash

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in porpoise.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 rubygems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# Porpoise
+
+## Welcome
+
+Porpoise implements a Redis like interface using MySQL as its storage engine. This provides an easy replacement for Rails applications that currently use Redis to store key/value data and would like to switch to MySQL for whatever reason.
+
+### Performance
+
+Redis outperforms this implementation by a long shot and I don't think I have to tell why. For an SQL based solution it still performs alright though. Besides, this thing integrates with Rails, uses ActiveRecord and all the bloat that comes with it. And altough a cache should help performance, cache read/write speed sometimes are not the bottleneck.
+
+### Then why?
+
+To simplify your stack? To get a real multi-master setup using MySQL/Galera? To get rid of an unstable situation?
+
+This gem was written out of the need to get rid of our shaky Redis Dynomite cluster which we implemented due to the requirement of having real multi-master clusters. Master-slave- and failover setups tend to break over time, so multi-master is the only acceptable way to go.
+
+So Redis /w Dynomite kept exploding at every little burp so we needed a solution. MySQL / Galera was already there as our primary datastore so the alternative was easily chosen. Reasons: proven multi-master setup and a more easy stack. With our userbase and use of Redis, performance was of minor importance.
+
+## Compatibility
+
+This gem has been tested with Rails 3, but probably also works with newer versions of Rails.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'porpoise'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install porpoise
+
+After installation of the gem, install the required migration:
+
+    $ rails generate porpoise:install
+
+Porpoise runs in a different database for easy optimization and decoupling. Add an entry in your config/database.yml for porpoise.
+
+    porpoise_development:
+        adapter: mysql2
+        username: <porpoise_db_user>
+        ...
+
+Run migrations to install the required table:
+
+    rake db:migrate
+
+## Usage
+
+### Caching in Rails
+
+Using Porpoise as caching backend in Rails is easy. Change your cache store config like this:
+
+    config.cache_store = :porpoise_store
+
+That's all! Optionally you can set a caching namespace like this:
+
+    config.cache_store = :porpoise_store, { namespace: :your_namespace }
+
+Namespacing automatically preprends each cache key with the chosen namespace.
+
+### As generic key/value storage
+ 
+Porpoise was designed as an easy replacement for Redis. Therefore it implements various of the commonly used types Redis knows (strings, sets and hashes) and most of their functions. Access them like this:
+
+    Porpoise::String.<redis-function-name-and-arguments>
+    Porpoise::Set.<redis-function-name-and-arguments>
+    Porpoise::Hash.<redis-function-name-and-arguments>
+
+Namespacing is easy as well. Surround your Porpoise calls in a block like this example:
+
+    Porpoise.with_namespace(:your_namespace) do
+        Porpoise::String.set('test-key', 'test-value')
+        Porpoise::Hash.hset('test-key', 'foo', 'bar')
+    end
+
+## Development
+
+Fork this repo. Development is done from within a Docker container for which the Dockerfile is included in this repo. Build and start the the container to access this gems development environment:
+
+    docker build -t porpoise-app .
+    docker run -it --rm -v "$PWD:/porpoise" porpoise-app
+
+Run all other actions from within the container. Tests:
+
+    bundle exec rspec spec
+
+Tests take some time as there's some performance tests included.
+
+Console:
+
+    ./bin/console
+
+PR's are welcome :)
+
+## Todo
+
+Of course there's still some work to do. Performance tests do not represent actual performance, as they currently use a memory store which should be file based to include disk I/O in the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sentialabs/porpoise.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'active_record'
+
+ENV['rack_env'] = 'test'
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+load File.join('spec/support/schema.rb')
+
+require "bundler/setup"
+require "porpoise"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/active_support/cache/porpoise_store.rb

@@ -0,0 +1,182 @@
+module ActiveSupport
+  module Cache
+    class PorpoiseStore < Store
+      # The maximum number of objects to store in
+      # the short life cache.
+      SHORT_LIFE_CACHE_SIZE = 5000
+
+      # The number of seconds items in the short
+      # cache are allowed to live.
+      SHORT_LIFE_CACHE_TIME = 5
+
+      attr_reader :namespace
+      attr_reader :slc, :slt # short life cache
+
+      def initialize(options = {})
+        @namespace = options.fetch(:namespace, "active-support-cache").to_s
+      end
+
+      def cleanup(options = nil)
+        short_mem_reset
+        Porpoise::KeyValueObject.where(["`key` LIKE ?", "#{@namespace}:%"]).
+                                 where(["expiration_date IS NOT NULL AND expiration_date < ?", Time.now]).
+                                 delete_all
+
+
+      end
+
+      def clear(options = nil)
+        short_mem_reset
+        Porpoise::KeyValueObject.where(["`key` LIKE ?", "#{@namespace}:%"]).delete_all
+      end
+
+      def decrement(name, amount, options = nil)
+        Porpoise.with_namespace(@namespace) { 
+          v = read(name)
+          v = v.to_i - amount.to_i
+          write(name, v, options)
+        }
+      end
+
+      def delete(name, options = nil)
+        Porpoise.with_namespace(@namespace) { 
+          short_mem_del(name)
+          Porpoise::Key.del(name)
+        }
+      end
+
+      def delete_matched(matcher, options = nil)
+        short_mem_reset
+        Porpoise.with_namespace(@namespace) { Porpoise::Key.del_matched(matcher) }
+      end
+
+      def exists?(name, options = nil)
+        Porpoise.with_namespace(@namespace) { Porpoise::Key.exists(name) == 1 }
+      end
+
+      def fetch(name, options = nil)
+        res = read(name)
+        if res.nil? && block_given?
+          res = yield(name)
+          write(name, res, options)
+        end
+        return res
+      end
+
+      def fetch_multi(*names)
+        res = read_multi(*names)
+        return res unless block_given?
+
+        mres = {}
+        res.each do |name, value|
+          if value.nil?
+            mres[name] = yield(name)
+            write(name, mres[name])
+          else
+            mres[name] = value
+          end
+        end
+
+        return mres
+      end
+
+      def increment(name, amount, options = nil)
+        Porpoise.with_namespace(@namespace) {
+          v = read(name)
+          v = v.to_i + amount.to_i
+          write(name, v, options)
+        }
+      end
+
+      def read(name, options = nil)
+        val = Porpoise.with_namespace(@namespace) {
+          short_mem_read(name) { Porpoise::String.get(name) }
+        }
+
+        begin
+          return val.nil? ? nil : Marshal.load(val)
+        rescue TypeError
+          return val
+        end
+      end
+
+      def read_multi(*names)
+        result = {}
+        names.each do |name|
+          val = Porpoise.with_namespace(@namespace) { 
+            short_mem_read(name) { Porpoise::String.get(name) }
+          }
+          begin
+            result[name] = (val.nil? ? nil : Marshal.load(val))
+          rescue TypeError
+            result[name] = val
+          end
+        end
+        return result
+      end
+
+      def write(name, value, options = nil)
+        options = {} if options.nil?
+        Porpoise.with_namespace(@namespace) {
+          short_mem_write(name, value, options) {
+            Porpoise::String.set(name, Marshal.dump(value), options.fetch(:expires_in, nil))
+          }
+        }
+      end
+
+      private
+
+      def short_mem_reset
+        @slc = {}
+        @slt = {}
+      end
+
+      def short_mem_write(name, value, options = nil)
+        @slc ||= {}
+        @slt ||= {}
+
+        # Do not write the short life cache if an item has an expiration time
+        unless options && options.has_key?(:expires_in)
+          @slt[name] = Time.now.to_i
+          @slc[name] = value
+
+          # Remove the oldest entries when cache gets to big
+          if @slt.keys.size >= SHORT_LIFE_CACHE_SIZE
+            kk = @slt.sort_by { |k,v| value }.shift(@slt.keys.size - SHORT_LIFE_CACHE_SIZE).map { |kv| kv[0] }
+            kk.each do |k|
+              @slt.delete(k)
+              @slc.delete(k)
+            end
+          end
+        end
+
+        yield if block_given?
+      end
+
+      def short_mem_read(name)
+        @slc ||= {}
+        @slt ||= {}
+        v = @slc.fetch(name, nil)
+        
+        # Remove dead items
+        if v && (@slt[name] + SHORT_LIFE_CACHE_TIME) < Time.now.to_i
+          @slc.delete(name)
+          @slt.delete(name)
+          v = nil
+        end
+
+        if v.nil? && block_given?
+          v = yield
+          short_mem_write(name, v) unless v.nil?
+        end
+
+        return v
+      end
+
+      def short_mem_del(name)
+        @slc.delete(name)
+        @slt.delete(name)
+      end
+    end
+  end
+end

data/lib/generators/porpoise/install_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+
+module Porpoise
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    desc "Install database migration file"
+    def create_migration_file
+      copy_file "migration.rb", "db/migrate/#{Date.today.strftime('%Y%m%d%H%M%S')}_porpoise_create_key_value_objects.rb"
+    end
+  end
+end

data/lib/generators/porpoise/templates/migration.rb

@@ -0,0 +1,20 @@
+class PorpoiseCreateKeyValueObjects < ActiveRecord::Migration
+  def up
+    Porpoise::KeyValueObject.connection.create_table :key_value_objects, id: false } do |t|
+      t.string :key, null: false
+      t.string :data_type, null: false, limit: 10
+      t.text :value, limit: 65000000, null: false
+      t.datetime :expiration_date
+    end
+
+    Porpoise::KeyValueObject.connection.add_index :key_value_objects, :key, unique: true
+    Porpoise::KeyValueObject.connection.add_index :key_value_objects, [:key, :expiration_date]
+    Porpoise::KeyValueObject.connection.add_index :key_value_objects, :key, name: 'key_fulltext_idx', type: :fulltext
+    Porpoise::KeyValueObject.connection.add_index :key_value_objects, :data_type
+    Porpoise::KeyValueObject.connection.add_index :key_value_objects, :expiration_date
+  end
+
+  def down
+    Porpoise::KeyValueObject.connection.drop_table :key_value_objects
+  end
+end

data/lib/porpoise/hash.rb

@@ -0,0 +1,129 @@
+module Porpoise
+  module Hash
+    class << self
+      def hdel(key, *fields)
+        o = find_stored_object(key)
+        current_keys = o.value.keys.size
+        o.value = o.value.delete_if { |k,v| fields.include?(k) }
+        o.save
+      
+        return current_keys - o.value.keys.size
+      end
+
+      def hexists(key, field)
+        o = find_stored_object(key)
+        o.value.has_key?(field) ? 1 : 0
+      end
+
+      def hget(key, field)
+        o = find_stored_object(key)
+        o.value.fetch(field, nil)
+      end
+
+      def hgetall(key)
+        o = find_stored_object(key)
+        o.value
+      end
+
+      def hincrby(key, field, increment)
+        o = find_stored_object(key)
+        o.value[field] += increment.to_i
+        o.save
+        o.value[field]
+      end
+
+      def hincrbyfloat(key, field, increment)
+        o = find_stored_object(key)
+        o.value[field] = (o.value[field] + increment.to_f).round(5)
+        o.save
+        o.value[field]
+      end
+
+      def hkeys(key)
+        o = find_stored_object(key)
+        o.value.keys
+      end
+
+      def hlen(key)
+        o = find_stored_object(key)
+        o.value.keys.size
+      end
+
+      def hmget(key, *fields)
+        o = find_stored_object(key)
+        fields.map { |f| o.value.fetch(f, nil) }
+      end
+
+      def hmset(key, *fields_and_values)
+        o = find_stored_object(key)
+        set_values = ::Hash[*fields_and_values]
+
+        set_values.keys.each do |k|
+          o.value[k] = set_values[k]
+        end
+        o.save
+      end
+
+      def hset(key, field, value)
+        o = find_stored_object(key)
+        current_value = o.value.fetch(field, "")
+        o.value[field] = value
+        
+        if o.save
+          return current_value == value ? 0 : 1
+        else
+          return 0
+        end
+      end
+
+      def hsetnx(key, field, value)
+        o = find_stored_object(key)
+        ahk = o.value.has_key?(field)
+        o.value[field] = value unless ahk
+        
+        if o.save
+          return ahk ? 0 : 1
+        else
+          return 0
+        end
+      end
+
+      def hstrlen(key, field)
+        o = find_stored_object(key)
+        o.value.fetch(field, "").to_s.size
+      end
+
+      def hvals(key)
+        o = find_stored_object(key)
+        o.value.values
+      end
+
+      private
+
+      def find_stored_object(key,
+          raise_on_type_mismatch = true,
+          raise_on_not_found = false)
+        
+        key = Porpoise::key_with_namespace(key)
+        o = Porpoise::KeyValueObject.not_expired.where(key: key).first
+        
+        if raise_on_type_mismatch && !o.nil? && o.data_type != 'Hash'
+          raise Porpoise::TypeMismatch.new(
+            "Key #{key} is not of type Hash (is #{o.data_type})"
+          )
+        end
+
+        if raise_on_not_found && o.nil?
+          raise Porpoise::KeyNotFound.new("Key #{key} could not be found")
+        elsif o.nil?
+          o = Porpoise::KeyValueObject.new(key: key, value: ::Hash.new)
+        elsif o.expired?
+          o.delete
+          o = Porpoise::KeyValueObject.new(key: key, value: ::Hash.new)
+        end
+
+        return o
+      end
+    end
+  end
+end

data/lib/porpoise/key.rb

@@ -0,0 +1,115 @@
+module Porpoise
+  module Key
+    class << self
+      def del(key, *other_keys)
+        o = find_stored_object(key)
+        aff = 0
+
+        unless o.nil?
+          o.delete
+          aff += 1
+        end 
+        
+        if other_keys.any?
+          aff += Porpoise::KeyValueObject.not_expired.
+            where(key: other_keys.map { |k| Porpoise::key_with_namespace(k) }).
+            delete_all
+        end
+
+        return aff
+      end
+
+      def del_matched(matcher)
+        matcher = Porpoise::key_with_namespace(matcher.gsub("*", "%"))
+        Porpoise::KeyValueObject.not_expired.where(["`key` LIKE ?", matcher]).delete_all
+      end
+
+      def dump(key)
+        o = find_stored_object(key)
+        return nil if o.nil?
+
+        Marshal.dump(o.value)
+      end
+
+      def exists(key, *other_keys)
+        all_keys = [key].concat(other_keys)
+        Porpoise::KeyValueObject.not_expired.
+          where(key: all_keys.map { |k| Porpoise::key_with_namespace(k) }).
+          count
+      end
+
+      def expire(key, seconds)
+        o = find_stored_object(key)
+        return 0 if o.nil?
+        o.expiration_date = (Time.now + seconds)
+
+        return o.save ? 1 : 0
+      end
+
+      def persist(key)
+        o = find_stored_object(key)
+        return 0 if o.nil? || o.expiration_date.blank?
+
+        o.expiration_date = nil
+        o.save ? 1 : 0
+      end
+
+      def rename(key, newkey)
+        o = find_stored_object(key, true)
+        no = find_stored_object(newkey)
+        
+        no.delete unless no.nil?
+        no = o.dup
+        no.key = newkey
+        o.delete
+
+        no.save
+      end
+
+      def type(key)
+        o = find_stored_object(key)
+        return false if o.nil?
+        return o.data_type
+      end
+
+      def ttl(key)
+        o = find_stored_object(key)
+        return -2 if o.nil?
+        return -1 if o.expiration_date.nil?
+        return o.expiration_date - Time.now
+      end
+
+      def keys(key_or_search_string)
+        if key_or_search_string.include?('*')
+          param = Porpoise::key_with_namespace(key_or_search_string.gsub('*', '%'))
+          ks = Porpoise::KeyValueObject.not_expired.
+            where(['`key` LIKE ?', param]).
+            pluck(:key)
+          
+            return Porpoise::namespace? ? ks.map { |k| k.sub("#{Porpoise::namespace}:", '') } : ks
+        else
+          param = Porpoise::key_with_namespace(key_or_search_string)
+          ks = Porpoise::KeyValueObject.not_expired.where(key: param).pluck(:key)
+          return Porpoise::namespace? ? ks.map { |k| k.sub("#{Porpoise::namespace}:", '') } : ks
+        end
+      end
+
+      private
+      
+      def find_stored_object(key, raise_on_not_found = false)
+        key = Porpoise::key_with_namespace(key)
+        o = Porpoise::KeyValueObject.where(key: key).first
+
+        if raise_on_not_found && o.nil?
+          raise Porpoise::KeyNotFound.new("Key #{key} could not be found")
+        elsif !o.nil? && o.expired?
+          o.delete
+          o = nil
+          raise Porpoise::KeyNotFound.new("Key #{key} could not be found") if raise_on_not_found
+        end
+
+        return o
+      end
+    end
+  end
+end

data/lib/porpoise/key_value_object.rb

@@ -0,0 +1,61 @@
+class Porpoise::KeyValueObject < ActiveRecord::Base
+  class Porpoise::TypeMismatch < StandardError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+  
+  class Porpoise::KeyNotFound < StandardError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+
+  self.primary_key = 'key'
+
+  # :nocov:
+  unless ENV['rack_env'] && ENV['rack_env'].eql?('test')
+    config = YAML.load(File.read('config/database.yml'))
+    establish_connection config["porpoise_#{Rails.env}"]
+  end
+  # :nocov:
+
+  serialize :value
+
+  attr_accessible :key, :value, :data_type, :expiration_date
+
+  after_initialize :check_data_type
+  before_validation :set_data_type
+
+  validates_inclusion_of :data_type, in: %w(String Hash Array)
+
+  scope :not_expired, conditions: ['(expiration_date IS NOT NULL AND expiration_date > ?) OR expiration_date IS NULL', Time.now]
+
+  def expired?
+    !self.expiration_date.nil? && self.expiration_date < Time.now
+  end
+  
+  def save
+    super
+  rescue ActiveRecord::RecordNotUnique
+    # catch race conditions
+    o = Porpoise::KeyValueObject.not_expired.where(key: self.key).first
+    o.value = self.value
+    o.expiration_date = self.expiration_date
+    o.save
+  end
+
+  private
+
+  def check_data_type
+    if !self.data_type.nil? && self.value.class.name != self.data_type
+      raise Porpoise::TypeMismatch.new(
+        "#{self.value.class.name} is not of type #{self.data_type}"
+      )
+    end
+  end   
+
+  def set_data_type
+    self.data_type = self.value.class.name
+  end
+end

data/lib/porpoise/set.rb

@@ -0,0 +1,194 @@
+module Porpoise
+  module Set
+    class << self
+      def sadd(key, *members)
+        o = find_stored_object(key)
+        previous_set = o.value.dup
+        o.value = o.value.concat(members).uniq
+        o.save
+
+        o.value.size - previous_set.size
+      end
+
+      def scard(key)
+        o = find_stored_object(key)
+        o.value.size
+      end
+
+      def sdiff(key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set = current_set - oo[ok].value
+        end
+        current_set
+      end
+
+      def sdiffstore(destination, key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set = current_set - oo[ok].value
+        end
+
+        no = find_stored_object(destination)
+        no.value = current_set
+        no.save
+        no.value.size
+      end
+
+      def sinter(key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set = current_set & oo[ok].value
+        end
+        return current_set
+      end
+
+      def sinterstore(destination, key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set = current_set & oo[ok].value
+        end
+
+        no = find_stored_object(destination)
+        no.value = current_set
+        no.save
+        no.value.size
+      end
+
+      def sismember(key, member)
+        o = find_stored_object(key)
+        return o.value.include?(member) ? 1 : 0
+      end
+
+      def smembers(key)
+        o = find_stored_object(key)
+        return o.value
+      end
+
+      def smove(source, destination, member)
+        Porpoise::KeyValueObject.transaction do
+          src = find_stored_object(source, false, true)
+          dst = find_stored_object(destination, false, true)
+          
+          ele = src.value.delete(member)
+          return 0 if ele.nil?
+
+          dst.value << ele unless dst.value.include?(ele)
+          res = dst.save && src.save
+
+          return (ele && res) ? 1 : 0
+        end
+      end
+
+      def spop(key, count = 1)
+        o = find_stored_object(key)
+        return nil if o.new_record?
+        
+        pd = [] 
+        count.times do
+          pd.push(o.value.shuffle!.pop) if o.value.size > 0
+        end
+       
+        o.save
+
+        return pd
+      end
+
+      def srandmember(key, count = 1)
+        o = find_stored_object(key)
+        return [] if o.new_record?
+
+        return o.value.sample(count)
+      end
+
+      def srem(key, member, *other_members)
+        o = find_stored_object(key)
+        return 0 if o.new_record?
+
+        previous_set = o.value.dup
+        all_members = [member].concat(other_members)
+        o.value = o.value.reject { |v| all_members.include?(v) }
+        o.save
+
+        previous_set - o.value
+      end
+
+      def sunion(key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value.dup
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set.concat(oo[ok].value)
+        end
+        current_set.uniq
+      end
+
+      def sunionstore(destination, key, *other_keys)
+        o = find_stored_object(key)
+        current_set = o.value.dup
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          next unless oo.has_key?(ok)
+          current_set.concat(oo[ok].value)
+        end
+
+        no = find_stored_object(destination)
+        no.value = current_set.uniq
+        no.save
+        no.value.size
+      end
+
+      private
+      
+      def find_stored_object(key, 
+                             raise_on_type_mismatch = true,
+                             raise_on_not_found = false)
+
+        key = Porpoise::key_with_namespace(key)
+        o = Porpoise::KeyValueObject.not_expired.where(key: key).first
+        
+        if raise_on_type_mismatch && !o.nil? && o.data_type != 'Array'
+          raise Porpoise::TypeMismatch.new(
+            "Key #{key} is not of type Set (is #{o.data_type})"
+          )
+        end
+
+        if raise_on_not_found && o.nil?
+          raise Porpoise::KeyNotFound.new("Key #{key} could not be found")
+        elsif o.nil?
+          o = Porpoise::KeyValueObject.new(key: key, value: ::Array.new)
+        elsif o.expired?
+          o.delete
+          o = Porpoise::KeyValueObject.new(key: key, value: ::Array.new)
+        end
+
+        return o
+      end
+    end
+  end
+end

data/lib/porpoise/string.rb

@@ -0,0 +1,155 @@
+module Porpoise
+  module String
+    class << self
+      def append(key, value)
+        o = find_stored_object(key)
+        o.value += value
+        o.save
+
+        o.value.size
+      end
+
+      def decr(key)
+        o = find_stored_object(key)
+        o.value = (o.value.to_i - 1).to_s
+        o.save
+
+        o.value
+      end
+
+      def decrby(key, decrement)
+        o = find_stored_object(key)
+        o.value = (o.value.to_i - decrement.to_i).to_s
+        o.save
+
+        o.value
+      end
+
+      def get(key)
+        o = find_stored_object(key)
+        return nil if o.new_record?
+        o.value
+      end
+
+      def getrange(key, first, last)
+        o = find_stored_object(key)
+        return nil if o.new_record?
+        o.value[first..last]
+      end
+
+      def getset(key, value)
+        o = find_stored_object(key)
+        return nil if o.new_record?
+        
+        ov = o.value
+        o.value = value
+        o.save
+
+        return ov
+      end
+
+      def incr(key)
+        o = find_stored_object(key)
+        o.value = (o.value.to_i + 1).to_s
+        o.save
+
+        o.value
+      end
+
+      def incrby(key, increment)
+        o = find_stored_object(key)
+        o.value = (o.value.to_i + increment.to_i).to_s
+        o.save
+
+        o.value
+      end
+
+      def mget(key, *other_keys)
+        o = find_stored_object(key)
+        values = o.new_record? ? [nil] : [o.value]
+        other_keys = other_keys.map { |k| Porpoise::key_with_namespace(k) }
+
+        oo = Porpoise::KeyValueObject.not_expired.where(key: other_keys).all.index_by(&:key)
+        other_keys.each do |ok|
+          values << (oo.has_key?(ok) ? oo[ok].value : nil)
+        end
+
+        return values
+      end
+
+      def mset(key, value, *other_keys_and_values)
+        Porpoise::KeyValueObject.transaction do
+          o = find_stored_object(key)
+          o.value = value
+          o.save
+
+          new_keys_and_values = ::Hash[*other_keys_and_values]
+          new_keys_and_values.each do |nk, nv|
+            oo = find_stored_object(nk)
+            oo.value = nv
+            oo.save
+          end
+        end
+        
+        return true
+      end
+
+      def setex(key, seconds, value)
+        o = find_stored_object(key)
+        o.value = value
+        o.expiration_date = Time.now + seconds
+        return o.save
+      end
+
+      def set(key, value, ex = nil, px = nil, nx_or_xx = nil)
+        o = find_stored_object(key, false)
+        o.value = value.to_s
+
+        if nx_or_xx
+          if nx_or_xx.downcase.eql?('nx')
+            return nil if !o.new_record?
+          elsif nx_or_xx.downcase.eql?('xx')
+            return nil if o.new_record?
+          end
+        end
+
+        o.expiration_date = (Time.now + ex) unless ex.nil?
+        o.expiration_date = (Time.now + (px / 1000)) unless px.nil?
+
+        o.save
+      end
+
+      def strlen(key)
+        o = find_stored_object(key)
+        o.value.size
+      end
+
+      private
+      
+      def find_stored_object(key,
+        raise_on_type_mismatch = true,
+        raise_on_not_found = false)
+        
+        key = Porpoise::key_with_namespace(key)
+        o = Porpoise::KeyValueObject.where(key: key).first
+        
+        if raise_on_type_mismatch && !o.nil? && o.data_type != 'String'
+          raise Porpoise::TypeMismatch.new(
+            "Key #{key} is not of type String (is #{o.data_type})"
+          )
+        end
+        
+        if raise_on_not_found && o.nil?
+          raise Porpoise::KeyNotFound.new("Key #{key} could not be found")
+        elsif o.nil?
+          o = Porpoise::KeyValueObject.new(key: key, value: ::String.new)
+        elsif o.expired?
+          o.delete
+          o = Porpoise::KeyValueObject.new(key: key, value: ::String.new)
+        end
+
+        return o
+      end
+    end
+  end
+end

data/lib/porpoise/util.rb

@@ -0,0 +1,9 @@
+module Porpoise
+  module Util
+    class << self
+      def ping
+        return Porpoise::KeyValueObject.count >= 0
+      end
+    end
+  end
+end

data/lib/porpoise/version.rb

@@ -0,0 +1,3 @@
+module Porpoise
+  VERSION = "0.9.0"
+end

data/lib/porpoise.rb

@@ -0,0 +1,37 @@
+require "porpoise/version"
+
+require "active_record"
+require "active_support"
+require "mysql2"
+
+# Porpoise specific
+require "porpoise/key_value_object"
+require "porpoise/util"
+require "porpoise/key"
+require "porpoise/string"
+require "porpoise/hash"
+require "porpoise/set"
+require "active_support/cache/porpoise_store"
+
+module Porpoise
+  class << self
+    def with_namespace(namespace)
+      Thread.current[:namespace] = namespace.to_s
+      res = yield
+      Thread.current[:namespace] = nil
+      res
+    end
+
+    def namespace
+      Thread.current[:namespace]
+    end
+
+    def namespace?
+      self.namespace && !self.namespace.blank?
+    end
+
+    def key_with_namespace(key)
+      self.namespace? ? "#{self.namespace}:#{key}" : key
+    end
+  end
+end

data/porpoise.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'porpoise/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "porpoise"
+  spec.version       = Porpoise::VERSION
+  spec.authors       = ["Wessel van Heerde"]
+  spec.email         = ["wessel.van.heerde@sentia.com"]
+  spec.licenses      = ['MIT']
+  spec.summary       = "MySQL key/value store with a Redis compatible interface. Store and access objects in a Redis like way using MySQL storage. Don't use for high performance, use for easy multi master clustering."
+  spec.homepage      = "https://dev-git.sentia.com/rubygems/porpoise"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2" 
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "simplecov", "~> 0"
+  spec.add_development_dependency "rspec-benchmark", "~> 0"
+
+  spec.add_dependency 'mysql2', '~> 0.3.20'
+  spec.add_dependency 'activerecord', "~> 3.2"
+  spec.add_dependency 'activesupport', "~> 3.2"
+  spec.add_dependency "rails", '~> 3.2'
+end

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: porpoise
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Wessel van Heerde
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.20
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.20
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: 
+email:
+- wessel.van.heerde@sentia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Dockerfile
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/active_support/cache/porpoise_store.rb
+- lib/generators/porpoise/install_generator.rb
+- lib/generators/porpoise/templates/migration.rb
+- lib/porpoise.rb
+- lib/porpoise/hash.rb
+- lib/porpoise/key.rb
+- lib/porpoise/key_value_object.rb
+- lib/porpoise/set.rb
+- lib/porpoise/string.rb
+- lib/porpoise/util.rb
+- lib/porpoise/version.rb
+- porpoise.gemspec
+homepage: https://dev-git.sentia.com/rubygems/porpoise
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: MySQL key/value store with a Redis compatible interface. Store and access
+  objects in a Redis like way using MySQL storage. Don't use for high performance,
+  use for easy multi master clustering.
+test_files: []