vinted-memcached 1.8.4 → 1.8.6

data/README.md

@@ -0,0 +1,144 @@
+# memcached
+
+An interface to the libmemcached C client.
+[![Build Status](https://github.com/arthurnn/memcached/workflows/CI/badge.svg?branch=1-0-stable)](https://github.com/arthurnn/memcached/actions?query=branch%3A1-0-stable)
+
+## License
+
+Copyright 2009-2013 Cloudburst, LLC. Licensed under the AFL 3. See the
+included LICENSE file. Portions copyright 2007-2009 TangentOrg, Brian Aker,
+licensed under the BSD license, and used with permission.
+
+## Features
+
+*   clean API
+*   robust access to all memcached features
+*   SASL support for the binary protocol
+*   multiple hashing modes, including consistent hashing
+*   ludicrous speed, including optional pipelined IO with no_reply
+
+
+The **memcached** library wraps the pure-C libmemcached client via SWIG.
+
+## Installation
+
+You need Ruby 1.8.7 or Ruby 1.9.2. Other versions may work, but are not
+guaranteed. You also need the `libsasl2-dev` and `gettext` libraries, which
+should be provided through your system's package manager.
+
+Install the gem:
+    sudo gem install memcached --no-rdoc --no-ri
+
+## Usage
+
+Start a local networked memcached server:
+    $ memcached -p 11211 &
+
+Now, in Ruby, require the library and instantiate a Memcached object at a
+global level:
+
+    require 'memcached'
+    $cache = Memcached.new("localhost:11211")
+
+Now you can set things and get things:
+
+    value = 'hello'
+    $cache.set 'test', value
+    $cache.get 'test' #=> "hello"
+
+You can set with an expiration timeout:
+
+    value = 'hello'
+    $cache.set 'test', value, 1
+    sleep(2)
+    $cache.get 'test' #=> raises Memcached::NotFound
+
+You can get multiple values at once:
+
+    value = 'hello'
+    $cache.set 'test', value
+    $cache.set 'test2', value
+    $cache.get ['test', 'test2', 'missing']
+      #=> {"test" => "hello", "test2" => "hello"}
+
+You can set a counter and increment it. Note that you must initialize it with
+an integer, encoded as an unmarshalled ASCII string:
+
+    start = 1
+    $cache.set 'counter', start.to_s, 0, false
+    $cache.increment 'counter' #=> 2
+    $cache.increment 'counter' #=> 3
+    $cache.get('counter', false).to_i #=> 3
+
+You can get some server stats:
+
+    $cache.stats #=> {..., :bytes_written=>[62], :version=>["1.2.4"] ...}
+
+Note that the API is not the same as that of **Ruby-MemCache** or
+**memcache-client**. In particular, `nil` is a valid record value.
+Memcached#get does not return `nil` on failure, rather it raises
+**Memcached::NotFound**. This is consistent with the behavior of memcached
+itself. For example:
+
+    $cache.set 'test', nil
+    $cache.get 'test' #=> nil
+    $cache.delete 'test'
+    $cache.get 'test' #=> raises Memcached::NotFound
+
+## Rails 3 and 4
+
+Use [memcached_store gem](https://github.com/Shopify/memcached_store) to
+integrate ActiveSupport cache store and memcached gem
+
+## Pipelining
+
+Pipelining updates is extremely effective in **memcached**, leading to more
+than 25x write throughput than the default settings. Use the following options
+to enable it:
+
+    :no_block => true,
+    :buffer_requests => true,
+    :noreply => true,
+    :binary_protocol => false
+
+Currently #append, #prepend, #set, and #delete are pipelined. Note that when
+you perform a read, all pending writes are flushed to the servers.
+
+## Threading
+
+**memcached** is threadsafe, but each thread requires its own Memcached
+instance. Create a global Memcached, and then call Memcached#clone each time
+you spawn a thread.
+
+    thread = Thread.new do
+      cache = $cache.clone
+      # Perform operations on cache, not $cache
+      cache.set 'example', 1
+      cache.get 'example'
+    end
+
+    # Join the thread so that exceptions don't get lost
+    thread.join
+
+## Legacy applications
+
+There is a compatibility wrapper for legacy applications called
+Memcached::Rails.
+
+## Benchmarks
+
+**memcached**, correctly configured, is at least twice as fast as
+**memcache-client** and **dalli**. See link:BENCHMARKS for details.
+
+## Reporting problems
+
+The support forum is [here](http://github.com/evan/memcached/issues).
+
+Patches and contributions are very welcome. Please note that contributors are
+required to assign copyright for their additions to Cloudburst, LLC.
+
+## Further resources
+
+*   [Memcached wiki](https://github.com/memcached/memcached/wiki)
+*   [Libmemcached homepage](libmemcached.org)
+

data/Rakefile

@@ -1,58 +1,26 @@
-require 'echoe'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake/extensiontask'
 
-Echoe.new("memcached") do |p|
-  p.author = "Evan Weaver"
-  p.project = "evan"
-  p.summary = "An interface to the libmemcached C client."
-  p.licenses = "Academic Free License 3.0 (AFL-3.0)"
-  p.rdoc_pattern = /README|TODO|LICENSE|CHANGELOG|BENCH|COMPAT|exceptions|experimental.rb|behaviors|rails.rb|memcached.rb/
-  p.rdoc_options = %w[--line-numbers --inline-source --title Memcached --main README.rdoc --exclude=ext/bin --exclude=ext/libmemcached-.*/(clients|tests)]
-  p.retain_gemspec = true
-  p.development_dependencies = ["rake", "mocha", "echoe", "activesupport"]
-  p.clean_pattern += ["ext/Makefile",
-                      "ext/bin",
-                      "ext/include",
-                      "ext/lib",
-                      "ext/share",
-                      "ext/**/Makefile",
-                      "ext/Makefile.in",
-                      "ext/libmemcached-*/autom4te.cache",
-                      "ext/libmemcached-*/clients/memcat",
-                      "ext/libmemcached-*/clients/memcp",
-                      "ext/libmemcached-*/clients/memdump",
-                      "ext/libmemcached-*/clients/memerror",
-                      "ext/libmemcached-*/clients/memflush",
-                      "ext/libmemcached-*/clients/memrm",
-                      "ext/libmemcached-*/clients/memslap",
-                      "ext/libmemcached-*/clients/memstat",
-                      "ext/libmemcached-*/tests/atomsmasher",
-                      "ext/libmemcached-*/tests/startservers",
-                      "ext/libmemcached-*/tests/testapp",
-                      "ext/libmemcached-*/tests/testplus",
-                      "ext/libmemcached-*/tests/udptest",
-                      "ext/libmemcached-*/config.h",
-                      "ext/libmemcached-*/config.log",
-                      "ext/libmemcached-*/config.status",
-                      "ext/libmemcached-*/docs/*.[1,3]",
-                      "ext/libmemcached-*/libmemcached/memcached_configure.h",
-                      "ext/libmemcached-*/libtool",
-                      "ext/libmemcached-*/stamp*",
-                      "ext/libmemcached-*/support/libmemcached.pc",
-                      "ext/libmemcached-*/support/libmemcached-fc.spec",
-                      "ext/libmemcached-*/**/*.s[oa]",
-                      "ext/libmemcached-*/**/*.l[oa]",
-                      "ext/conftest.dSYM",
-                      "lib/rlibmemcached*",
-                      "**/*.rbc"]
+spec = Gem::Specification.load('memcached.gemspec')
+Rake::ExtensionTask.new('rlibmemcached', spec) do |ext|
+  ext.lib_dir = 'lib'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+  t.warning = true
+end
+task :default => [:compile, :test]
+
+Rake::Task[:clean].enhance do
+  FileUtils.rm_rf(File.read(".gitignore").lines.flat_map { |l| Dir["**/#{l.chomp}"] })
 end
 
 task :swig do
-  run("swig -DLIBMEMCACHED_WITH_SASL_SUPPORT -Iext/libmemcached-0.32 -ruby -autorename -o ext/rlibmemcached_wrap.c.in ext/rlibmemcached.i", "Running SWIG")
-  swig_patches = {
-    "#ifndef RUBY_INIT_STACK" => "#ifdef __NEVER__" # Patching SWIG output for JRuby.
-  }.map{|pair| "s/#{pair.join('/')}/"}.join(';')
-  # sed has different syntax for inplace switch in BSD and GNU version, so using intermediate file
-  run("sed '#{swig_patches}' ext/rlibmemcached_wrap.c.in > ext/rlibmemcached_wrap.c", "Apply patches to SWIG output")
+  run("swig -DLIBMEMCACHED_WITH_SASL_SUPPORT -Ivendor/libmemcached-0.32 -ruby -autorename -o ext/rlibmemcached/rlibmemcached_wrap.c ext/rlibmemcached/rlibmemcached.i", "Running SWIG")
 end
 
 task :exceptions do
@@ -83,47 +51,7 @@ task :valgrind do
  exec("ruby #{File.dirname(__FILE__)}/test/profile/valgrind.rb")
 end
 
-def with_vm(vm, cmd)
-  bindir = vm.split("/")[0..-2].join("/")
-  puts "#{vm} #{cmd} started"
-  if !File.exist?("#{bindir}/rake")
-    puts "#{vm} not found"
-    exit(1)
-  elsif system("bash --norc --noprofile -c 'export PATH=#{bindir}:/bin:/usr/bin && which rake && #{bindir}/rake clean && #{bindir}/rake compile'")
-    puts "#{vm} compiled"
-    if system("bash --norc --noprofile -c 'export PATH=#{bindir}:/bin:/usr/bin && #{bindir}/rake #{cmd}'")
-      puts "#{vm} #{cmd} success (1st try)"
-    elsif system("bash --norc --noprofile -c 'export PATH=#{bindir}:/bin:/usr/bin && #{bindir}/rake #{cmd}'")
-      puts "#{vm} #{cmd} success (2nd try)"
-    else
-      puts "#{vm} #{cmd} failed"
-      exit(1)
-    end
-  else
-    puts "#{vm} compilation failed"
-    exit(1)
-  end
-end
-
-task :test_20 do
-  with_vm("/usr/bin/ruby", "test")
-end
-
-task :test_19 do
-  with_vm("/opt/local/bin/ruby1.9", "test")
-end
-
-task :test_rbx do
-  with_vm("/usr/local/rubinius/1.2.4/bin/rbx", "test")
-end
-
-task :test_all => [:test_20, :test_19, :test_rbx]
-
-task :prerelease => [:manifest, :test_all, :install]
-
-task :benchmark_all do
-  with_vms("benchmark CLIENT=libm")
-end
+task :prerelease => [:manifest, :test, :install]
 
 def run(cmd, reason)
   puts reason
@@ -131,7 +59,7 @@ def run(cmd, reason)
   raise "'#{cmd}' failed" unless system(cmd)
 end
 
-task :version do |t|
+task :version do
   require 'memcached/version'
   puts Memcached::VERSION
 end

data/ext/rlibmemcached/extconf.rb

@@ -0,0 +1,76 @@
+require 'mkmf'
+require 'rbconfig'
+require 'fileutils'
+
+unless find_header('sasl/sasl.h')
+  abort 'Please install SASL to continue. The package is called libsasl2-dev on Ubuntu and cyrus-sasl on Gentoo.'
+end
+
+HERE = File.expand_path(File.dirname(__FILE__))
+LIBMEMCACHED_DIR = Dir.glob(File.join(HERE, '..', '..', 'vendor',"libmemcached-*")).first
+
+SOLARIS_32 = RbConfig::CONFIG['target'] == "i386-pc-solaris2.10"
+BSD = RbConfig::CONFIG['host_os'].downcase =~ /bsd/
+
+$CFLAGS = "#{RbConfig::CONFIG['CFLAGS']} #{$CFLAGS}".gsub("$(cflags)", "").gsub("-fno-common", "").gsub("-Werror=declaration-after-statement", "").gsub("-Werror=shorten-64-to-32", "").gsub("-Werror=deprecated-declarations", "")
+$CFLAGS << " -Os"
+$CFLAGS << " -std=gnu99" if SOLARIS_32
+$CFLAGS << " -I/usr/local/include" if BSD
+$EXTRA_CONF = " --disable-64bit" if SOLARIS_32
+$LDFLAGS = "#{RbConfig::CONFIG['LDFLAGS']} #{$LDFLAGS} -L#{RbConfig::CONFIG['libdir']}".gsub("$(ldflags)", "").gsub("-fno-common", "")
+$CXXFLAGS = "#{RbConfig::CONFIG['CXXFLAGS']} -std=gnu++98"
+$CC = "CC=#{RbConfig::MAKEFILE_CONFIG["CC"].inspect}"
+
+LIBM_CFLAGS = $CFLAGS
+LIBM_LDFLAGS = $LDFLAGS
+
+GMAKE_CMD = RbConfig::CONFIG['host_os'].downcase =~ /bsd|solaris/ ? "gmake" : "make"
+TAR_CMD = SOLARIS_32 ? 'gtar' : 'tar'
+PATCH_CMD = SOLARIS_32 ? 'gpatch' : 'patch'
+
+if ENV['DEBUG']
+  puts "Setting debug flags."
+  $CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
+  $EXTRA_CONF = ""
+end
+
+def check_libmemcached
+  return if ENV["EXTERNAL_LIB"]
+
+  Dir.chdir(LIBMEMCACHED_DIR) do
+    # Cleanup any previously built files since the following touch all files command
+    # could make them seem rebuilt when there are changes that require recompiling them.
+    FileUtils.rm_rf("build")
+    run("#{GMAKE_CMD} clean 2>&1") if File.exist?("Makefile")
+    ts_now=Time.now.strftime("%Y%m%d%H%M.%S")
+    run("find . | xargs touch -t #{ts_now}", "Touching all files so autoconf doesn't run.")
+
+    Dir.mkdir("build")
+    build_folder = File.join(LIBMEMCACHED_DIR, "build")
+    run("env CFLAGS='-fPIC #{LIBM_CFLAGS}' LDFLAGS='-fPIC #{LIBM_LDFLAGS}' ./configure --prefix=#{build_folder} --libdir=#{build_folder}/lib --without-memcached --disable-shared --disable-utils --disable-dependency-tracking #{$CC} #{$EXTRA_CONF} 2>&1", "Configuring libmemcached.")
+    run("#{GMAKE_CMD} CXXFLAGS='#{$CXXFLAGS}' 2>&1")
+    run("#{GMAKE_CMD} install 2>&1")
+
+
+    pcfile = File.join(LIBMEMCACHED_DIR, "build", "lib", "pkgconfig", "libmemcached.pc")
+    $LDFLAGS << " -lsasl2 " + `pkg-config --libs --static #{pcfile}`.strip
+  end
+
+
+  $DEFLIBPATH.unshift("#{LIBMEMCACHED_DIR}/build")
+  dir_config('memcached', "#{LIBMEMCACHED_DIR}/build/include", "#{LIBMEMCACHED_DIR}/build/lib")
+end
+
+def run(cmd, reason = nil)
+  puts reason if reason
+  puts cmd
+  raise "'#{cmd}' failed" unless system(cmd)
+end
+
+check_libmemcached
+
+unless have_library 'memcached' and have_header 'libmemcached/memcached.h'
+  abort "ERROR: Failed to build libmemcached"
+end
+
+create_makefile 'rlibmemcached'

data/ext/{rlibmemcached.i → rlibmemcached/rlibmemcached.i}

@@ -3,7 +3,6 @@
 #include <libmemcached/visibility.h>
 #include <libmemcached/memcached.h>
 #include <libmemcached/memcached_exist.h>
-#include <ruby/version.h>
 %}
 
 %warnfilter(SWIGWARN_RUBY_WRONG_NAME) memcached_st;
@@ -110,12 +109,16 @@
  $result = UINT2NUM($1);
 };
 
+%typemap(in, numinputs=0) (const char **key, size_t *key_length) {
+  const char *key_ptr;
+  size_t key_length_ptr;
+  $1 = &key_ptr;
+  $2 = &key_length_ptr;
+}
+
 // String for memcached_fetch
-%typemap(in, numinputs=0) (char *key, size_t *key_length) {
-  char string[256];
-  size_t length = 0;
-  $1 = string;
-  $2 = &length;
+%typemap(argout) (const char **key, size_t *key_length) {
+  rb_ary_push($result, rb_str_new(*$1, *$2));
 };
 
 // Strings with lengths
@@ -150,87 +153,63 @@
 %include "libmemcached/memcached_touch.h"
 %include "libmemcached/memcached_exist.h"
 
-//// Custom C functions
-
-VALUE rb_str_new_by_ref(char *ptr, long len);
-%{
-VALUE rb_str_new_by_ref(char *ptr, long len)
-{
-#ifdef OBJSETUP
-    NEWOBJ(str, struct RString);
-    OBJSETUP(str, rb_cString, T_STRING);
-    #ifdef RSTRING_NOEMBED
-        /* Ruby 1.9 */
-        str->as.heap.ptr = ptr;
-        #if RUBY_API_VERSION_MAJOR < 3 || (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR < 3)
-            str->as.heap.len = len;
-        #else
-            // Ruby 3.3.0 moved the len field out of heap into toplevel RString
-            str->len = len;
-        #endif
-        str->as.heap.aux.capa = len + 1;
-        // Set STR_NOEMBED
-        FL_SET(str, FL_USER1);
-    #else
-        /* Ruby 1.8 */
-        str->ptr = ptr;
-        str->len = len;
-        str->aux.capa = 0;
-    #endif
-#else
-    /* Rubinius, JRuby */
-    VALUE str = rb_str_new(ptr, len);
-    free(ptr);
-#endif
-    return (VALUE)str;
-}
-%}
-
 //// Manual wrappers
 
-// Single get
-VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
-%{
-VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
-  size_t value_length = 0;
-  char *value = memcached_get(ptr, key, key_length, &value_length, flags, error);
-  return rb_str_new_by_ref(value, value_length);
-};
-%}
-
-VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error);
-%{
-VALUE memcached_get_len_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t user_spec_len, uint32_t *flags, memcached_return *error) {
-  size_t value_length = 0;
-  char *value = memcached_get_len(ptr, key, key_length, user_spec_len, &value_length, flags, error);
-  return rb_str_new_by_ref(value, value_length);
-};
-%}
-
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
 %{
 VALUE memcached_get_from_last_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
   size_t value_length = 0;
   char *value = memcached_get_from_last(ptr, key, key_length, &value_length, flags, error);
-  return rb_str_new_by_ref(value, value_length);
+  VALUE str = rb_str_new(value, value_length);
+  free(value);
+  return str;
 };
 %}
 
 // Multi get
-VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error);
+VALUE memcached_fetch_rvalue(memcached_st *ptr, const char **key, size_t *key_length, uint32_t *flags, memcached_return *error);
 %{
-VALUE memcached_fetch_rvalue(memcached_st *ptr, char *key, size_t *key_length, uint32_t *flags, memcached_return *error) {
-  size_t value_length = 0;
+VALUE memcached_fetch_rvalue(memcached_st *ptr, const char **key, size_t *key_length, uint32_t *flags, memcached_return *error) {
   VALUE ary = rb_ary_new();
-  *key_length = 0;
-  if (error) *error = MEMCACHED_TIMEOUT; // timeouts leave error uninitialized
-  char *value = memcached_fetch(ptr, key, key_length, &value_length, flags, error);
-  VALUE str = rb_str_new_by_ref(value, value_length);
+
+  *error = MEMCACHED_TIMEOUT; // timeouts leave error uninitialized
+  memcached_result_st *result = memcached_fetch_result(ptr, &ptr->result, error);
+  VALUE str = Qnil;
+  if (result == NULL || *error != MEMCACHED_SUCCESS) {
+    *key = NULL;
+    *key_length = 0;
+    *flags = 0;
+    str = Qnil;
+  } else {
+    *key = memcached_result_key_value(result);
+    *key_length = memcached_result_key_length(result);
+    *flags = memcached_result_flags(result);
+    str = rb_str_new(memcached_result_value(result), memcached_result_length(result));
+  }
   rb_ary_push(ary, str);
   return ary;
 };
 %}
 
+// Single get
+VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error);
+%{
+VALUE memcached_get_rvalue(memcached_st *ptr, const char *key, size_t key_length, uint32_t *flags, memcached_return *error) {
+  *error = memcached_mget(ptr, &key, &key_length, 1);
+  if (*error != MEMCACHED_SUCCESS) {
+    return rb_ary_new_from_args(1, Qnil);
+  }
+  VALUE ret = memcached_fetch_rvalue(ptr, &key, &key_length, flags, error);
+  if (*error == MEMCACHED_END) {
+    *error = MEMCACHED_NOTFOUND;
+  } else {
+    memcached_return end_error;
+    memcached_fetch_result(ptr, &ptr->result, &end_error);
+  }
+  return ret;
+};
+%}
+
 // Ruby isn't aware that the pointer is an array... there is probably a better way to do this
 memcached_server_st *memcached_select_server_at(memcached_st *in_ptr, int index);
 %{