evented-memcache-client 1.0.0

data/lib/evented_memcache_client/connection.rb

@@ -0,0 +1,73 @@
+#############################################################################
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  module Protocols
+    module Memcache
+
+      # Implements a memcache protocol connection.
+      
+      class Connection < EventMachine::Connection
+
+        include Connectable
+
+        ######################################################################
+        # EventMachine::Connection entry points
+        ######################################################################
+
+        # Create a new connection.  Args are a hash of callbacks (or a
+        # Module -- see Connectable#set_handler).
+        # 
+        # Note that when you're using EventMachine, you won't be
+        # calling Connection::new yourself - EM does it for you when a
+        # connection is established.
+        # 
+        # Eg:
+        #   callbacks = {
+        #     :open => Proc.new { |conn|
+        #       conn.set(:key => 'x', :data => Time.now.to_s)
+        #     },
+        #     :stored => Proc.new { |conn, data, args|
+        #       puts "Stored a value"
+        #       EventMachine::stop
+        #     },
+        #   }
+        #   EventMachine::run {
+        #     EventMachine::connect('127.0.0.1',
+        #                           12345,
+        #                           EventMachine::Protocols::Memcache::Connection,
+        #                           callbacks)
+        #   }
+        # 
+        def initialize(*args)
+          super(*args)
+          return if !args || args.empty?
+          set_handler(args[0])
+        end
+
+      end # Connection
+    end # Memcache
+  end # module Protocols
+end # module EventMachine

data/lib/evented_memcache_client/sender.rb

@@ -0,0 +1,184 @@
+#############################################################################
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module EventMachine
+  module Protocols
+    module Memcache
+
+      # Interface for sending memcache protocol messages like STORE,
+      # END, etc.  See
+      # http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
+      # for more details.
+      #
+      # NB: since several methods are defined dynamically here using
+      # define_method, they don't show up in the RDoc-generated
+      # documentation.  Sorry.
+      
+      module Sender
+
+        # Keeps stats on message sends.        
+        def book_it(msg_type)
+          @snd_stats[msg_type] ||= 0
+          @snd_stats[msg_type] += 1
+        end
+
+        # Wish these could be properly rdoc'd...
+        %w(set add replace append prepend).each { |cmd|
+          class_eval do
+            define_method "#{cmd}" do |args|
+              book_it(cmd.to_sym)
+              key       = args[:key]
+              flags     = args[:flags] || 0
+              exptime   = args[:exptime] || 0
+              noreply   = args[:noreply] || false
+              data      = args[:data]
+              raise ArgumentError.new(':data cannot be nil') unless data
+              raise ArgumentError.new(':key cannot be nil') unless key
+              cmd_str = "#{cmd} #{key} #{flags} #{exptime} #{data.length}"
+              cmd_str << " noreply" if noreply
+              send_to_peer "#{cmd_str}\r\n#{data}\r\n"
+            end
+          end
+        }
+
+        # Send a cas request to the memcached server.
+        def cas(*args)
+          book_it(:cas)
+          key           = args[:key]
+          flags         = args[:flags] || 0
+          exptime       = args[:exptime] || 0
+          cas_uniq      = args[:cas_uniq]
+          noreply       = args[:noreply] || false
+          data          = args[:data]
+          raise ArgumentError.new(':data cannot be nil') unless data
+          raise ArgumentError.new(':key cannot be nil') unless key
+          raise ArgumentError.new(':cas_uniq cannot be nil') unless cas_uniq
+          cmd_str = "cas #{key} #{flags} #{exptime} #{data.length} #{cas_uniq}"
+          cmd_str << " noreply" if noreply
+          send_to_peer "#{cmd_str}\r\n#{data}\r\n"
+        end
+
+        # Send a get request to the memcached server.  +args+ must
+        # have a :keys key if it is a hash, otherwise it's assumed
+        # that it is a single key.  Eg., get('queue') or
+        # get(:keys=>['queue_a', 'queue_b']) or get(:key=>'queue').
+        def get(args)
+          if args.respond_to?(:keys)
+            keys = args[:keys] || [args[:key]]
+          else
+            keys = [args]
+          end
+          raise ArgumentError.new('No keys specified.') if keys.empty?
+          send_to_peer "get #{keys.join(' ')}\r\n"
+        end
+        alias_method :gets, :get
+        
+        # Send a delete request to the memcached server.  +args+ is a
+        # Hash with a required :key member, and optional :time and
+        # :noreply members.
+        def delete(*args)
+          book_it(:delete)
+          key           = args[:key]
+          time          = args[:time] || 0
+          noreply       = args[:noreply] || false
+          raise ArgumentError.new(':key cannot be nil') unless key
+          cmd_str = "delete #{key}"
+          cmd_str << " #{time}" if time > 0
+          cmd_str << " noreply" if noreply
+          send_to_peer "#{cmd_str}\r\n"
+        end
+
+        # Wish these could be properly rdoc'd...
+        %w(incr decr).each { |cmd|
+          class_eval do
+            define_method "#{cmd}" do |args|
+              book_it(cmd.to_sym)
+              key               = args[:key]
+              value     = args[:value] || 0
+              noreply   = args[:noreply] || false
+              raise ArgumentError.new(':key cannot be nil') unless key
+              raise ArgumentError.new(':value cannot be nil') unless value
+              cmd_str = "#{cmd} #{key} #{value}"
+              cmd_str << " noreply" if noreply
+              send_to_peer "#{cmd_str}\r\n"
+            end
+          end
+        }
+
+        # Send a stats request to the memcached server.  +args+ is a
+        # Array that specifies the specific stats command as defined
+        # in the memcache protocol.
+        def stats(*args)
+          book_it(:stats)
+          cmd_str = "stats #{args.join(' ')}"
+          send_to_peer "#{cmd_str}\r\n"
+        end
+
+        # Wish these could be properly rdoc'd...
+        %w(flush_all version quit).each { |cmd|
+          class_eval do
+            define_method "#{cmd}" do
+              book_it(cmd.to_sym)
+              send_to_peer "#{cmd}\r\n"
+            end
+          end
+        }
+
+        # Wish these could be properly rdoc'd...
+        %w(stored end).each { |cmd|
+          class_eval do
+            define_method "#{cmd}" do
+              book_it(cmd.to_sym)
+              send_to_peer "#{cmd.upcase}\r\n"
+            end
+          end
+        }
+
+        # Send a value message to the remote endpoint (client); this
+        # is a server-sent message.  +args+ is a
+        # Hash with a required :key member, and optional :flash and
+        # :cas_uniq members.  Hash must also include a :data
+        # member (the payload to be sent).
+        def value(args)
+          book_it(:value)
+          key           = args[:key]
+          flags         = args[:flags] || 0
+          cas_uniq      = args[:cas_uniq]
+          data          = args[:data]
+          raise ArgumentError.new(':data cannot be nil') unless data
+          raise ArgumentError.new(':key cannot be nil') unless key
+          cmd_str = "VALUE #{key} #{flags} #{data.length}"
+          cmd_str << " #{cas_uniq}" if cas_uniq
+          send_to_peer "#{cmd_str}\r\n#{data}\r\n"
+        end
+
+        # Send a memcache protocol message contained in the :data
+        # argument to the remote endpoint.
+        def send_to_peer(data)
+          @msgs_out ||= 0
+          @msgs_out += 1
+          send_data(data)
+        end
+      end # Sender
+    end # Memcache
+  end  # Protocols
+end # EventMachine

data/lib/evented_memcache_client/server.rb

@@ -0,0 +1,118 @@
+#############################################################################
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  module Protocols
+    module Memcache
+      class Server
+
+        DEFAULT_PORT = 22122
+        DEFAULT_HOST = 'localhost'
+
+        attr_accessor :connections
+        attr :host, true
+        attr :port, true
+
+        # Create a new memcache server listener, on the specified host
+        # and port. 
+        def initialize(host=nil, port=nil)
+          @host 	= host || DEFAULT_HOST
+          @port 	= port || DEFAULT_PORT
+          @connections 	= []
+        end
+
+        # Start listening for client connections.
+        def start
+          begin
+            @signature = EventMachine.start_server(@host,
+                                                   @port.to_i,
+                                                   Connectable,
+                                                   self) { |conn|
+              conn.set_handler(self)
+
+              # Usually called from EM; we fake it out.
+              conn.connection_completed
+            }
+          rescue => e
+            return false
+          else
+            return true
+          end
+        end
+
+        # Stop listening for client connections, and close any open
+        # clients.
+        def stop
+          EventMachine.stop_server(@signature)
+          unless wait_for_connections
+            # Still some running
+            EventMachine.add_periodic_timer(1) {
+              wait_for_connections
+            }
+          end
+        end
+
+
+        ######################################################################
+        # Callbacks from the connection
+        ######################################################################
+
+        def open(conn)
+          @connections << conn
+        end
+
+        def close(conn)
+          @connections.delete(conn)
+        end
+
+        def set(conn, data, args)
+          # we don't do nuffing
+        end
+        alias_method :replace, :set
+        alias_method :prepend, :set
+        alias_method :append, :set
+        alias_method :add, :set
+
+        def get(conn, data, args)
+          # we don't do nuffing
+        end
+
+        protected
+
+        def wait_for_connections
+          if @connections.empty?
+            true
+          else
+            @connections.each { |c|
+              c.close_connection_after_writing
+            }
+            false
+          end
+        end
+        
+      end # Server
+    end # Memcache
+  end # module Protocols
+end # module EventMachine

data/lib/evented_memcache_client/tenacious.rb

@@ -0,0 +1,106 @@
+#############################################################################
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'rubygems'
+require 'eventmachine'
+
+module EventMachine
+  module Protocols
+    module Memcache
+
+      # TenaciousMC is a "tenacious" memcache client connection.  When
+      # the underlying connection is lost, it attempts to reacquire it
+      # automatically.
+      
+      class TenaciousMC < Client
+        
+        # Create a new "tenacious" connection, which will attempt to
+        # reacquire a connection to the server if it is lost.
+        # 
+        # Note that when you're using EventMachine, you won't be
+        # calling TenaciousMC::new yourself - EM does it for you when a
+        # connection is established.
+        # 
+        # First argument as per EventMachine::Protocols::Memcache::Client.
+        # Ie., callback hash, module or handler object.
+        # 
+        # Second argument is hash of options governing TenaciousMC's
+        # behavior:
+        # 
+        #   { :host => 'somewhere.com', :port=>12345, :interval => 5 }
+        # 
+        # If the options hash includes a :eager key, and its value is
+        # true, then when the connection opens, TenaciousMC will
+        # immediately send a 'get' to the server to fetch data, using
+        # the value of the :key option as the key fetched.
+        # 
+        # So a typical invocation:
+        # 
+        #   EventMachine::run {
+        #     EventMachine::connect('over.there',
+        #                           12345,
+        #                           EventMachine::Protocols::Memcache::TenaciousMC,
+        #                           MyHandlerModule,
+        #                           {:host => 'over.there', :port => 12345})
+        #   }
+        def initialize(*args)
+          @handle_arg   = args[0]
+          options       = args[1]
+          @host         = options[:host] || 'localhost'
+          @port         = options[:port]
+          raise "No port option is set" unless @port
+          @interval     = options[:interval] || 5
+          @eager        = options[:eager] || false
+          @key          = options[:key] || nil
+          super(*args)
+        end
+        
+        # Called from EM::Connection after the connection is established.
+        def connection_completed
+          super
+          if @eager && @key
+            self.get(:key => @key)
+          end
+        end
+
+        # Called from EM::Connection when the connection is dead.
+        def unbind
+          super
+          if @interval > 0
+            EventMachine::add_timer(@interval) do
+              EventMachine::connect(@host,
+                                    @port,
+                                    self.class,
+                                    @handle_arg,
+                                    {
+                                      :host => @host,
+                                      :port => @port,
+                                      :interval => @interval
+                                    })
+            end
+          end
+        end
+
+      end # TenaciousMC
+    end # Memcache
+  end # module Protocols
+end # module EventMachine