rusty_redic 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc86989c5716583f7009fc180288d3d7968634a2
+  data.tar.gz: eec8c481510b5603f9d969831010c8c1d3c46184
+SHA512:
+  metadata.gz: 8d1267d475534ff066f775370167fbbdeb28e6374a10bf29716b4fd91f0f82e9791a775eecce70970e2d4b39c3590e03bee40b59bae7691831caa9622c7cc59f
+  data.tar.gz: bc7dcb5a9713272616db3798a703268e95acedbb1e399bdbaa88a7ca0b71a052f6e84399645da9338f2d2a1aa3f416b0dd26b4b127c6c2bd3bf6cc16bb05cf18

data/.appveyor.yml

@@ -0,0 +1,79 @@
+platform:
+  - x86
+  - x64
+environment:
+  matrix:
+    - RUST_VERSION: stable
+      BUILD_TARGET: gnu
+      RUBY_VERSION: 23
+cache:
+  - target\debug\build
+  - target\debug\deps
+  - '%USERPROFILE%\.cargo'
+install:
+  - ps: |
+        $env:PATH += ";C:\rust\bin";
+        if ($env:platform -eq 'x86') {
+          $env:RUBY_DIR = "Ruby${env:RUBY_VERSION}"
+          $arch_expanded = "i686-pc-windows-${env:BUILD_TARGET}";
+          $env:ARCH = "x86";
+          $env:bits = "32";
+        } else {
+          $env:RUBY_DIR = "Ruby${env:RUBY_VERSION}-x64"
+          $arch_expanded = "x86_64-pc-windows-${env:BUILD_TARGET}";
+          $env:ARCH = "amd64";
+          $env:bits ="64";
+        }
+        $env:WIN_RUBY_BIN = "C:\${env:RUBY_DIR}\bin";
+        $env:PATH = "${env:WIN_RUBY_BIN};${env:PATH}";
+        if ($env:BUILD_TARGET -eq 'gnu') {
+          $env:PATH += ";C:\msys64\mingw${env:bits}\bin";
+          gcc --version;
+        }
+        if ($env:RUST_VERSION -eq 'stable') {
+          echo "Downloading $channel channel manifest";
+          Start-FileDownload "https://static.rust-lang.org/dist/channel-rust-stable";
+
+          $env:RUST_VERSION = Get-Content channel-rust-stable | Select -first 1 | %{$_.split('-')[1]}
+        }
+        $env:rust_installer = "rust-${env:RUST_VERSION}-${arch_expanded}.exe";
+        $tag_suffix = echo "${env:APPVEYOR_REPO_TAG_NAME}" | Select-String -pattern "-rust$"
+        if ($tag_suffix) {
+          $env:RUST_TAG = "1";
+        }
+  - curl --show-error --location --retry 5 --output rust-installer.exe https://static.rust-lang.org/dist/%rust_installer%
+  - .\rust-installer.exe /VERYSILENT /NORESTART /DIR="C:\rust"
+  - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH%
+  - rustc -vV
+  - cargo -vV
+  - ruby --version
+  - gem --version
+  - rake --version
+  - bundle --version
+  - bundle config --local path vendor/bundle
+  - bundle install
+build_script:
+  - bundle exec rake --trace thermite:tarball
+test_script:
+  - bundle exec rake --trace test
+  - ps: |
+        if ($env:RUST_TAG -ne '1') {
+          bundle exec rake --trace install;
+          gem uninstall rusty_blank;
+          gem install minitest;
+          del "${env:WIN_RUBY_BIN}\rake"
+          gem install "pkg\*.gem";
+          ruby "test\test_rusty_blank.rb";
+        }
+artifacts:
+  - path: rusty_blank-*.tar.gz
+deploy:
+  - provider: GitHub
+    artifact: /rusty_blank-.*\.tar\.gz/
+    draft: false
+    prerelease: false
+    auth_token:
+      secure: VUF+Nfn07Dym0IlQHG3NO6SdHMa1uG8IVzRY+beMUPR49b6M5mTvpPTm3OWO40G7
+    on:
+      appveyor_repo_tag: true
+      RUST_TAG: 1

data/.gitignore

@@ -0,0 +1,10 @@
+.ruby-version
+.bundle
+mkmf.log
+target
+*.dll
+*.dylib
+*.gem
+*.lock
+*.so
+*.tar.gz

data/.travis.yml

@@ -0,0 +1,75 @@
+sudo: false
+dist: trusty
+language: rust
+services:
+- redis-server
+os:
+- linux
+- osx
+dist: trusty
+osx_image: xcode8
+rust: stable
+env:
+  global:
+  - THERMITE_DEBUG_FILENAME: /tmp/thermite-debug.log
+  matrix:
+  - R_RUBY_VERSION: 2.3.3
+  - R_RUBY_VERSION: 2.4.0
+
+cache:
+  cargo: true
+  directories:
+  - $TRAVIS_BUILD_DIR/vendor/bundle
+  - $HOME/.cache/pip
+
+before_install:
+- |
+  rvm install "$R_RUBY_VERSION"
+  rvm use "$R_RUBY_VERSION"
+  ruby --version
+  if [[ "$TRAVIS_OS_NAME" == "osx" ]] && ! which bundle > /dev/null; then
+    gem install bundler
+  fi
+- bundle install --jobs=3 --retry=3 --path=$TRAVIS_BUILD_DIR/vendor/bundle
+
+before_script:
+- |
+  export PATH=$HOME/Library/Python/2.7/bin:$HOME/.local/bin:$PATH
+  if [[ "$TRAVIS_OS_NAME" == "osx" ]] && ! which pip > /dev/null; then
+    wget https://bootstrap.pypa.io/get-pip.py
+    python get-pip.py --user
+  fi
+  pip install 'travis-cargo<0.2' --user
+
+script:
+- travis-cargo build
+- bundle exec rake test
+- bundle exec rake thermite:tarball
+- bundle exec rake install
+- |
+  if [[ -z "$TRAVIS_TAG" ]]; then
+    gem uninstall rusty_redic
+    CARGO=fake bundle exec rake install
+  fi
+- |
+  if [[ -z "$TRAVIS_TAG" ]]; then
+    gem uninstall rusty_redic
+    gem install minitest
+    CARGO=fake gem install pkg/*.gem
+    ruby test/test_rusty_redic.rb
+  fi
+- if [[ -f "$THERMITE_DEBUG_FILENAME" ]]; then cat $THERMITE_DEBUG_FILENAME; fi
+
+deploy:
+  provider: releases
+  api_key:
+    secure: kPF5xzVgW42igOf3AIqY1CGEn3Q4Dc9QEfdxkPlcSWsnHDSqDfdSqZn4yHsb8BFLtrR4Hd1QxerWVIKtitG5Mz/PX9i7vXzyXVNjX29vfWVvV4x9dqN4ZCcTHaU5MGMOqQ646fIdJZfzgMEaXztD3wFXOPxd1eBl3eBz1tDvOib9SnQF+qclbtdCJw8Q+LShOXQzzjplhfsGSJ7W1r8wtFiEHZILG88UCbJUneOo5YnL4lPQcF8m0/5N2aAO+Y1bcdK/zjygQdMQhqKPWVLrosnpY+2Y/Hs/6nzCi2PKuU0PPqEb7Ak8j9ikYKaNrlQCFBAsDZbPzfFdC9OlIQiURMsu2OIoUMb0F3sPGeTUAx4hvbI96XmCTsLb/+sySuRKQXwsN5D6gggnKZm/AhqA0mzKjjyUCPxLsLjittbQMCoRwdAIipkgfifrjqwnhzyjgf6FqYEJ/nFwkFP79GWk08mYzAsyqFlR0cdVn/LdJwazTu4DPbL2z+N0+C3rQeiysgvCOqrNv86inD36o9qMRPJq4dl08Add6Rd5qlNMHtoGNhKZJADawAR0o7fKhKOYHj5M6VWJPkY6TXE4g9QjfJ39qqWWZBrjbwZG5Z0zGYA2VZ/az4Avh8Uytfnc9Fjk+H+vy8xuXX6bACnUj/VVXy0H4+xS2+KZj157HFdD1mk=
+  file: rusty_redic-*.tar.gz
+  file_glob: true
+  skip_cleanup: true
+  on:
+    condition: ${TRAVIS_TAG} =~ '-rust'
+    repo: badboy/rusty_redic
+    tags: true
+notifications:
+  email: false

data/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "rusty-redic"
+version = "0.2.0"
+authors = ["Jan-Erik Rediger <janerik@fnordig.de>"]
+repository = "https://github.com/badboy/rusty_redic"
+publish = false
+
+[package.metadata.thermite]
+
+github_releases = true
+github_release_type = "latest"
+# Only for github_release_type = "cargo"
+# git_tag_format = "v%s-rust"
+git_tag_regex = "^v(\\d+\\.\\d+\\.\\d+)-rust$"
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+ruru = "0.9"
+redis = "0.8.0"
+lazy_static = "0.2.1"

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org/'
+
+gemspec
+
+gem 'thermite', github: 'malept/thermite'
+gem 'redic'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jan-Erik Rediger
+
+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/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'thermite/tasks'
+
+thermite = Thermite::Tasks.new
+
+task default: %w(thermite:build)
+
+desc 'Run testsuite'
+task test: %w(thermite:build thermite:test) do
+  test_file = File.join(File.dirname(__FILE__), 'test', 'test_rusty_redic.rb')
+  ruby "#{test_file} #{thermite.config.ruby_extension_path}"
+  ruby test_file
+end

data/lib/rusty_redic.rb

@@ -0,0 +1,6 @@
+require 'thermite/fiddle'
+
+toplevel_dir = File.dirname(File.dirname(__FILE__))
+Thermite::Fiddle.load_module('init_rusty_redic',
+                             cargo_project_path: toplevel_dir,
+                             ruby_project_path: toplevel_dir)

data/rusty_redic.gemspec

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require 'English'
+
+Gem::Specification.new do |s|
+  s.name        = 'rusty_redic'
+  s.version     = '0.2.0'
+  s.summary     = 'Lightweight Redis Client, in Rust'
+  s.description = 'A lightweight Redis Client, written in Rust, as minimal as Redic'
+
+  s.authors     = ['Jan-Erik Rediger']
+  s.email       = 'janerik@fnordig.de'
+  s.homepage    = 'https://github.com/badboy/rusty_redic'
+  s.license     = 'MIT'
+
+  s.extensions    = %w(Rakefile)
+  s.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  s.require_paths = %w(lib)
+  s.test_files    = %w(test/test_rusty_redic.rb)
+
+  s.add_runtime_dependency 'thermite', '~> 0'
+  s.add_development_dependency 'minitest', '~> 5.8'
+end

data/src/lib.rs

@@ -0,0 +1,217 @@
+#[macro_use]
+extern crate ruru;
+#[macro_use]
+extern crate lazy_static;
+
+extern crate redis;
+
+use std::str;
+use std::error::Error;
+use ruru::{Class, Object, RString, Array, AnyObject, NilClass, VM, Fixnum};
+
+pub struct Redic {
+    client: redis::Client,
+    conn: Option<redis::Connection>,
+    queue: Vec<Vec<String>>,
+}
+
+impl Redic {
+    pub fn new(client: redis::Client) -> Redic {
+        Redic {
+            client: client,
+            conn: None,
+            queue: vec![],
+        }
+    }
+
+    pub fn client(&self) -> &redis::Client {
+        &self.client
+    }
+
+    pub fn queue(&mut self) -> &mut Vec<Vec<String>> {
+        &mut self.queue
+    }
+
+    pub fn connection(&mut self) -> &redis::Connection {
+        if self.conn.is_some() {
+            return self.conn.as_ref().unwrap();
+        }
+
+        let con = match self.client.get_connection() {
+            Ok(con) => con,
+            Err(_)     => {
+                VM::raise(Class::from_existing("ArgumentError"), "Can't create connection");
+                unreachable!();
+            }
+        };
+        self.conn = Some(con);
+        self.conn.as_ref().unwrap()
+    }
+}
+
+wrappable_struct!(Redic, RedicWrapper, REDIC_WRAPPER);
+
+class!(RustyRedic);
+
+fn redis_value_to_any_object(val: redis::Value) -> AnyObject {
+    match val {
+        redis::Value::Nil => NilClass::new().to_any_object(),
+        redis::Value::Int(i) => Fixnum::new(i).to_any_object(),
+        redis::Value::Data(vec) => {
+            unsafe {
+                let s = str::from_utf8_unchecked(&vec);
+                RString::new(s).to_any_object()
+            }
+        }
+        redis::Value::Bulk(vec) => {
+            let mut v = Array::new();
+            for elem in vec {
+                v.push(redis_value_to_any_object(elem));
+            }
+            v.to_any_object()
+        }
+        redis::Value::Status(s) => RString::new(&s).to_any_object(),
+        redis::Value::Okay => RString::new("OK").to_any_object()
+    }
+}
+
+methods!(
+    RustyRedic,
+    itself,
+
+    fn redic_new(url: RString) -> AnyObject {
+        let default_url = "redis://localhost:6379";
+        let url = url
+            .map(|url| url.to_string())
+            .unwrap_or_else(|_| default_url.to_string());
+        let client = match redis::Client::open(&*url) {
+            Ok(client) => client,
+            Err(_)     => {
+                VM::raise(Class::from_existing("ArgumentError"), "Can't create RustyRedic");
+                unreachable!();
+            }
+        };
+        let redic = Redic::new(client);
+
+        Class::from_existing("RustyRedic")
+            .wrap_data(redic, &*REDIC_WRAPPER)
+    }
+
+    fn redic_call(args: Array) -> AnyObject {
+        let args = match args {
+            Err(error) => {
+                VM::raise(error.to_exception(), error.description());
+                unreachable!();
+            }
+            Ok(args) => args
+        };
+        if args.length() == 0 {
+            VM::raise(Class::from_existing("ArgumentError"), "Need atleast 1 argument");
+            unreachable!();
+        }
+
+        let con = itself.get_data(&*REDIC_WRAPPER).connection();
+
+        let mut args = args.into_iter()
+            .map(|obj| {
+                let obj = match obj.try_convert_to::<RString>() {
+                    Ok(obj) => obj,
+                    Err(_)     => {
+                        VM::raise(Class::from_existing("ArgumentError"), "Can't coerce to String");
+                        unreachable!();
+                    }
+                };
+                obj.to_string()
+            });
+
+        let cmd = args.next().unwrap();
+        let mut cmd = redis::cmd(&cmd);
+        for arg in args {
+            cmd.arg(&arg);
+        }
+
+        let res : redis::RedisResult<redis::Value> = cmd.query(con);
+
+        match res {
+            Err(_) => {
+                VM::raise(Class::from_existing("ArgumentError"), "Can't execute command");
+                unreachable!();
+            }
+            Ok(val) => redis_value_to_any_object(val)
+        }
+    }
+
+    fn redic_queue(args: Array) -> NilClass {
+        let args = match args {
+            Err(error) => {
+                VM::raise(error.to_exception(), error.description());
+                unreachable!();
+            }
+            Ok(args) => args
+        };
+        if args.length() == 0 {
+            VM::raise(Class::from_existing("ArgumentError"), "Need atleast 1 argument");
+            unreachable!();
+        }
+
+        let args = args.into_iter()
+            .map(|obj| {
+                let obj = match obj.try_convert_to::<RString>() {
+                    Ok(obj) => obj,
+                    Err(_)     => {
+                        VM::raise(Class::from_existing("ArgumentError"), "Can't coerce to String");
+                        unreachable!();
+                    }
+                };
+                obj.to_string()
+            }).collect::<Vec<String>>();
+
+        let mut queue = itself.get_data(&*REDIC_WRAPPER).queue();
+        queue.push(args);
+
+        NilClass::new()
+
+    }
+
+    fn redic_commit() -> AnyObject {
+        let mut queue = itself.get_data(&*REDIC_WRAPPER).queue();
+        if queue.is_empty() {
+            return NilClass::new().to_any_object();
+        }
+
+        let con = itself.get_data(&*REDIC_WRAPPER).connection();
+
+        let mut pipe = redis::pipe();
+        for cmd in queue.drain(..) {
+            let mut args = cmd.iter();
+            let first = args.next().unwrap();
+            pipe.cmd(first);
+            for arg in args {
+                pipe.arg(arg);
+            }
+        }
+
+        let res : redis::RedisResult<redis::Value> = pipe.query(con);
+
+        match res {
+            Err(_) => {
+                VM::raise(Class::from_existing("ArgumentError"), "Can't execute command");
+                unreachable!();
+            }
+            Ok(val) => redis_value_to_any_object(val)
+        }
+    }
+);
+
+#[no_mangle]
+pub extern fn init_rusty_redic() {
+    let data_class = Class::from_existing("Data");
+
+    Class::new("RustyRedic", Some(&data_class)).define(|itself| {
+        itself.def_self("new", redic_new);
+
+        itself.def("call", redic_call);
+        itself.def("queue", redic_queue);
+        itself.def("commit", redic_commit);
+    });
+}

data/test/test_rusty_redic.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'rusty_redic'
+
+#
+# Extremely basic unit test for rusty_redic
+#
+class TestRustyRedic < MiniTest::Test
+  def test_new
+    assert RustyRedic.new
+  end
+
+  def test_call
+    redic = RustyRedic.new
+
+    assert_equal "OK", redic.call(["SET", "foo", "bar"])
+    assert_equal "bar", redic.call(["GET", "foo"])
+  end
+
+  def test_pipeline
+    redic = RustyRedic.new
+
+    redic.queue(["SET", "foo", "bar"])
+    redic.queue(["GET", "foo"])
+
+    assert_equal ["OK", "bar"], redic.commit
+  end
+end

data/throughput.rb

@@ -0,0 +1,76 @@
+# Compare performance of redic with rusty_redic
+#
+# Run with
+#
+#   $ bundle exec rake thermite:build
+#   $ bundle exec throughput.rb
+#
+
+require "rubygems"
+require "benchmark"
+require "rusty_redic"
+require "redic"
+
+$redic = Redic.new
+$rusty_redic = RustyRedic.new
+
+# make sure both are connected
+$redic.call("PING")
+$rusty_redic.call(["PING"])
+
+$redic.call(:flushdb)
+
+def without_gc
+  GC.start
+  GC.disable
+  yield
+ensure
+  GC.enable
+end
+
+def pipeline(b,num,size,title,cmd)
+  commands = size.times.map { cmd }
+
+  x = without_gc {
+    b.report("redic:       %2dx #{title} pipeline, #{num} times" % size) {
+      num.times {
+        commands.each { |cmd| $redic.queue(*cmd) }
+        $redic.commit
+      }
+    }
+  }
+
+  y = without_gc {
+    b.report("rusty_redic: %2dx #{title} pipeline, #{num} times" % size) {
+      num.times {
+        commands.each { |cmd| $rusty_redic.queue(cmd) }
+        $rusty_redic.commit
+      }
+    }
+  }
+
+  puts "%.1fx" % [1 / (y.real / x.real)]
+end
+
+Benchmark.bm(50) do |b|
+  pipeline(b,10000, 1, "SET", %w(set foo bar))
+  pipeline(b,10000,10, "SET", %w(set foo bar))
+  puts
+
+  pipeline(b,10000, 1, "GET", %w(get foo))
+  pipeline(b,10000,10, "GET", %w(get foo))
+  puts
+
+  pipeline(b,10000, 1, "LPUSH", %w(lpush list fooz))
+  pipeline(b,10000,10, "LPUSH", %w(lpush list fooz))
+  puts
+
+  pipeline(b,1000, 1, "LRANGE(100)", %w(lrange list 0  99))
+  puts
+
+  pipeline(b,1000, 1, "LRANGE(1000)", %w(lrange list 0 999))
+  puts
+
+  # Clean up...
+  redic.call(:flushdb)
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: rusty_redic
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jan-Erik Rediger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thermite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+description: A lightweight Redis Client, written in Rust, as minimal as Redic
+email: janerik@fnordig.de
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".appveyor.yml"
+- ".gitignore"
+- ".travis.yml"
+- Cargo.toml
+- Gemfile
+- LICENSE
+- Rakefile
+- lib/rusty_redic.rb
+- rusty_redic.gemspec
+- src/lib.rs
+- test/test_rusty_redic.rb
+- throughput.rb
+homepage: https://github.com/badboy/rusty_redic
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Lightweight Redis Client, in Rust
+test_files:
+- test/test_rusty_redic.rb