ruby-memcached 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11f93dfef10cbbbc92972e071a7662c78ada89bbc098fc59905ad386c5a62c25
+  data.tar.gz: e94b21ce9b83b03bd204114b2344ae398971428e1154f1508daeebbfb17ca7cc
+SHA512:
+  metadata.gz: 10d7e9ca7df90a8f07f66d5627cc4b9012b2e66762014800d796650424403a49ae2855bd20052982051094bd2f862e515ae84ef9e87c0ff43210a53075d3064f
+  data.tar.gz: 0a25744a8187a5d3f1d48a23e10ebe89d4ab6e830ff5f6ddb42ea7f881c0488ffd0aed2a5f025ac754832bdf618aa427ad0551ffe03f8d1cb62c6ace741a16f4

data/bin/memcached-client.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require_relative '../lib/ruby-memcached.rb'
+
+
+host = ARGV[0]
+port = ARGV[1]
+server = TCPSocket.new(host, port)
+
+listener = Thread.new {
+    while response = server.gets()
+        puts("Server: " + response)
+    end
+}
+
+speaker = Thread.new {
+    while true
+        print("> ")
+        server.puts(STDIN.gets())
+        break if $_ =~ RubyMemcached::CommandsRegex.end
+        sleep(0.1)
+    end
+}
+
+listener.join()
+speaker.join()
+
+server.close()

data/bin/memcached-server.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/ruby-memcached.rb'
+
+puts('Creating server...')
+host = ARGV[0]
+port = ARGV[1]
+gc_interval = ARGV[2].to_i()
+
+server = RubyMemcached::Server.new(host, port)
+
+main = Thread.new {
+    puts('Starting server...')
+    server.start()
+}
+
+gc = Thread.new {
+    server.start_gc(gc_interval) if gc_interval > 0
+}
+
+main.join()
+puts('Server closed')

data/lib/ruby-memcached.rb

@@ -0,0 +1,3 @@
+require_relative './ruby-memcached/Memcached.rb'
+require_relative './ruby-memcached/Server.rb'
+require_relative './ruby-memcached/Client.rb'

data/lib/ruby-memcached/Client.rb

@@ -0,0 +1,161 @@
+require 'socket'
+
+require_relative './Memcached.rb'
+require_relative './Constants.rb'
+
+module RubyMemcached
+    class Client
+
+        attr_reader :host
+        attr_reader :port
+
+        def initialize(host, port)
+            @host = host
+            @port = port
+            @server = TCPSocket.new(host, port)
+        end
+
+        def get(keys)
+            keys_string = keys.reduce { |ss, s| ss + ' ' + s }
+            @server.puts(Commands.get % keys_string)
+
+            items = []
+
+            loop do
+                case @server.gets()
+                    when ResponsesRegex.get
+                        key = $~['key']
+                        flags = $~['flags'].to_i()
+                        bytes = $~['bytes'].to_i()
+                        data = @server.read(bytes + 1).chomp()
+
+                        items << Memcached::Item.new(key, data, flags, 0, bytes, nil)
+
+                    when ResponsesRegex.end
+                        break
+
+                    when /.*ERROR.*/
+                        break
+                end
+            end
+
+            return items
+        end
+
+        def gets(keys)
+            keys_string = keys.reduce { |ss, s| ss + ' ' + s }
+            @server.puts(Commands.gets % keys_string)
+
+            items = []
+
+            loop do
+                case @server.gets()
+                    when ResponsesRegex.gets
+                        key = $~['key']
+                        flags = $~['flags'].to_i()
+                        bytes = $~['bytes'].to_i()
+                        cas_id = $~['cas_id'].to_i()
+                        data = @server.read(bytes + 1).chomp()
+
+                        items << Memcached::Item.new(key, data, flags, 0, bytes, cas_id)
+
+                    when ResponsesRegex.end
+                        break
+
+                    when /.*ERROR.*/
+                        break
+                end
+            end
+
+            return items
+        end
+
+        def set(key, flags, exptime, bytes, data)
+            @server.puts(Commands.set % [
+                key,
+                flags,
+                exptime,
+                bytes,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]           
+        end
+
+        def add(key, flags, exptime, bytes, data)
+            @server.puts(Commands.add % [
+                key,
+                flags,
+                exptime,
+                bytes,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]           
+        end
+
+        def replace(key, flags, exptime, bytes, data)
+            @server.puts(Commands.replace % [
+                key,
+                flags,
+                exptime,
+                bytes,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]           
+        end
+
+        def append(key, bytes, data)
+            @server.puts(Commands.append % [
+                key,
+                bytes,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]                       
+        end
+
+        def prepend(key, bytes, data)
+            @server.puts(Commands._prepend % [
+                key,
+                bytes,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]                       
+        end
+
+        def cas(key, flags, exptime, bytes, cas_id, data)
+            @server.puts(Commands.cas % [
+                key,
+                flags,
+                exptime,
+                bytes,
+                cas_id,
+                '',
+                data
+            ])
+
+            return Responses.to_h[Responses.key @server.gets()]           
+        end
+
+        def delete(key)
+            @server.puts(Commands.delete % key)
+            return Responses.to_h[Responses.key @server.gets()]        
+        end
+
+        def end()
+            @server.puts(Commands.end)
+        end
+
+        def reconnect()
+            @server = TCPSocket.new(@host, @port)
+        end
+    end
+end

data/lib/ruby-memcached/Constants.rb

@@ -0,0 +1,5 @@
+require_relative './constants/Commands.rb'
+require_relative './constants/CommandsRegex.rb'
+require_relative './constants/Errors.rb'
+require_relative './constants/Responses.rb'
+require_relative './constants/ResponsesRegex.rb'

data/lib/ruby-memcached/Item.rb

@@ -0,0 +1,38 @@
+module RubyMemcached
+    class Memcached::Item
+
+        attr_accessor :key
+        attr_accessor :data
+        attr_accessor :flags
+        attr_accessor :exptime
+        attr_accessor :bytes
+        attr_accessor :cas_id
+        
+        attr_accessor :lock
+    
+        def initialize(key, data, flags, exptime, bytes, cas_id)
+            @key = key
+            @data = data
+            @flags = flags
+            @bytes = bytes
+            @exptime = get_exptime(exptime.to_i)
+            @cas_id = cas_id
+
+            @lock = Mutex.new()
+        end
+
+        def to_s()
+            return @key
+        end
+    end
+end
+
+def get_exptime(exptime)
+    if (exptime == 0)
+        return nil
+    elsif (exptime < 1592000)
+        return Time.now().getutc() + exptime
+    else
+        return Time.at(exptime)
+    end
+end

data/lib/ruby-memcached/Memcached.rb

@@ -0,0 +1,121 @@
+require 'concurrent'
+
+module RubyMemcached
+    class Memcached
+
+        attr_reader :storage
+    
+        def initialize
+            @storage = Concurrent::Hash.new()
+        end
+    
+        def get(key)
+            self.check_exptime(key)
+            return @storage[key]
+        end
+    
+        def get_multi(keys)
+            result = []
+            for key in keys do
+                item = self.get(key)
+                result.append(item) unless item.nil?
+            end
+            return result
+        end
+    
+        def set(key, flags, exptime, bytes, data)
+            if(@storage.key?(key))
+                cas_id = @storage[key].cas_id + 1
+            else
+                cas_id = 0
+            end
+            new_item = Item.new(key, data, flags, exptime, bytes, cas_id)
+            @storage.store(key, new_item)
+            return Responses.stored
+        end
+    
+        def add(key, flags, exptime, bytes, data)
+            self.check_exptime(key)
+
+            return Responses.not_stored if @storage.key?(key)
+            new_item = Item.new(key, data, flags, exptime, bytes, 0)
+            @storage.store(key, new_item)
+            return Responses.stored
+        end
+    
+        def replace(key, flags, exptime, bytes, data)
+            self.check_exptime(key)
+
+            return Responses.not_stored unless @storage.key?(key)
+            cas_id = @storage[key].cas_id + 1
+            new_item = Item.new(key, data, flags, exptime, bytes, cas_id)
+            @storage.store(key, new_item)
+            return Responses.stored
+        end
+    
+        def append(key, bytes, data)
+            self.check_exptime(key)
+
+            return Responses.not_stored unless @storage.key?(key)
+            @storage[key].data.concat(data)
+            @storage[key].bytes += bytes
+            @storage[key].cas_id += 1
+            return Responses.stored
+        end
+    
+        def prepend(key, bytes, data)
+            self.check_exptime(key)
+
+            return Responses.not_stored unless @storage.key?(key)
+            @storage[key].data.prepend(data)
+            @storage[key].bytes += bytes
+            @storage[key].cas_id += 1
+            return Responses.stored
+        end
+    
+        def cas(key, flags, exptime, bytes, cas_id, data)
+            self.check_exptime(key)
+
+            return Responses.not_found unless @storage.key?(key)
+            
+            old_item = @storage[key]
+            old_item.lock.synchronize do
+                return Responses.exists if old_item.cas_id != cas_id
+    
+                new_item = Item.new(key, data, flags, exptime, bytes, old_item.cas_id + 1)
+                @storage.store(key, new_item)
+                return Responses.stored
+            end
+        end
+
+        def delete(key)
+            return Responses.not_found unless @storage.key?(key)
+            @storage.delete(key)
+            return Responses.deleted
+        end
+
+        def check_exptime(key)
+            value = @storage[key]
+            return true if value.nil?() || value.exptime.nil?()
+
+            current_time = Time.now().getutc()
+
+            if (current_time > value.exptime)
+                @storage.delete(key)
+                return false
+            end 
+
+            return true
+        end
+
+        def check_exptimes()
+            deleted = 0
+            @storage.each_key do | key |
+                delete += 1 unless self.check_exptime(key)
+            end
+            return deleted
+        end
+    end
+end
+
+require_relative './Item.rb'

data/lib/ruby-memcached/Server.rb

@@ -0,0 +1,194 @@
+require 'socket'
+
+require_relative './/Memcached.rb'
+require_relative './Constants.rb'
+
+module RubyMemcached
+    class Server
+
+        attr_reader :host
+        attr_reader :port
+        attr_accessor :storage
+    
+        def initialize(host, port)
+            @host = host
+            @port = port
+            @connection = TCPServer.new(host, port)
+            @memc = Memcached.new()
+        end
+
+        def start
+            loop do
+                Thread.start(@connection.accept()) do | client |
+                
+                    puts('Opening connection to %s' % client.to_s)
+    
+                    continue_condition = true
+    
+                    while command = client.gets()
+                        printf('%s: %s' % [client.to_s(), command])
+                        begin
+                            continue_condition = parse(command, client) unless command.nil?                        
+                        rescue => e
+                            client.puts(Errors.server_error % e.message)
+                            puts(Errors.server_error % e.message)
+                        end
+                        break unless continue_condition
+                    end
+    
+                    client.close()
+                    puts('Closing connection to %s' % [client.to_s()])
+                end
+            end
+        end
+    
+        def parse(command, client)
+            case command
+                when CommandsRegex.get
+                    self.get(client, $~)
+    
+                when CommandsRegex.gets
+                    self.gets(client, $~)
+    
+                when CommandsRegex.set
+                    self.set(client, $~)
+    
+                when CommandsRegex.add
+                    self.add(client, $~)
+                    
+                when CommandsRegex.replace
+                    self.replace(client, $~)
+    
+                when CommandsRegex.append
+                    self.append(client, $~)
+    
+                when CommandsRegex.prepend
+                    self.prepend(client, $~)
+    
+                when CommandsRegex.cas
+                    self.cas(client, $~)
+
+                when CommandsRegex.delete
+                    self.delete(client, $~)
+
+                when CommandsRegex.end
+                    return false;
+                else
+                    client.puts(Errors.client_error % [": Invalid command"])
+            end
+            
+            return true
+        end
+    
+        def get_data(client, bytes)
+            return client.read(bytes + 1).chomp()
+        end
+    
+        def get(client, command)
+            keys = command['keys'].split(' ')
+            items = @memc.get_multi(keys)
+    
+            for item in items
+                client.puts(Responses.get % [item.key, item.flags, item.bytes, item.data]) unless item.nil?()
+            end
+            client.puts(Responses.end)
+        end
+    
+        def gets(client, command)
+            keys = command['keys'].split(' ')
+            items = @memc.get_multi(keys)
+    
+            for item in items
+                client.puts(Responses.gets % [item.key, item.flags, item.bytes, item.cas_id, item.data]) unless item.nil?()
+            end
+            client.puts(Responses.end)
+        end
+    
+        def set(client, command)
+            key = command['key']
+            flags = command['flags']
+            exptime = command['exptime']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.set(key, flags, exptime, bytes, data)
+            client.puts(response) unless noreply
+        end
+    
+        def add(client, command)
+            key = command['key']
+            flags = command['flags']
+            exptime = command['exptime']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.add(key, flags, exptime, bytes, data)
+            client.puts(response) unless noreply
+        end
+    
+        def replace(client, command)
+            key = command['key']
+            flags = command['flags']
+            exptime = command['exptime']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.replace(key, flags, exptime, bytes, data)
+            client.puts(response) unless noreply
+        end
+    
+        def append(client, command)
+            key = command['key']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.append(key, bytes, data)
+            client.puts(response) unless noreply
+        end
+    
+        def prepend(client, command)
+            key = command['key']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.prepend(key, bytes, data)
+            client.puts(response) unless noreply
+    
+        end
+    
+        def cas(client, command)
+            key = command['key']
+            flags = command['flags']
+            exptime = command['exptime']
+            bytes = command['bytes'].to_i()
+            data = self.get_data(client, bytes)
+            cas_id = command['cas_id'].to_i()
+            noreply = !command['noreply'].nil?
+    
+            response = @memc.cas(key, flags, exptime, bytes, cas_id, data)
+            client.puts(response) unless noreply
+        end
+
+        def delete(client, command)
+            key = command['key']
+            noreply = !command['noreply'].nil?
+
+            response = @memc.delete(key)
+            client.puts(response) unless noreply
+        end
+
+        def start_gc(interval, loops = nil)
+
+            while loops.nil?() || loops > 0
+                sleep(interval)
+                puts('Garbage collector deleted: %d' % @memc.check_exptimes())
+                loops -= 1 unless loops.nil?()
+            end
+        end
+    end
+end

data/lib/ruby-memcached/constants/Commands.rb

@@ -0,0 +1,26 @@
+require 'ruby-enum'
+
+module RubyMemcached
+    class Commands
+        include Ruby::Enum
+
+        define :get, "get %s\n"
+        define :gets, "gets %s\n"
+
+        define :set, "set %s %d %d %d%s\n%s\n"
+        define :add, "add %s %d %d %d%s\n%s\n"
+        define :replace, "replace %s %d %d %d%s\n%s\n"
+
+        define :append, "append %s %d%s\n%s\n"
+        define :_prepend, "prepend %s %d%s\n%s\n"
+
+        define :cas, "cas %s %d %d %d %d%s\n%s\n"
+
+        define :delete, "delete %s%s\n"
+
+        define :incr, "incr %s %d%s\n%d\n"
+        define :decr, "decr %s %d%s\n%d\n"
+
+        define :end, "END\n"
+    end
+end

data/lib/ruby-memcached/constants/CommandsRegex.rb

@@ -0,0 +1,26 @@
+require 'ruby-enum'
+
+module RubyMemcached
+    class CommandsRegex
+        include Ruby::Enum
+
+        define :get, /^get (?<keys>(\w|[ ])+)\n/
+        define :gets, /^gets (?<keys>(\w|[ ])+)\n/
+    
+        define :set, /^set (?<key>(\w)+) (?<flags>[0-9]+) (?<exptime>[0-9]+) (?<bytes>[0-9]+)(?<noreply> noreply)?\n/
+        define :add, /^add (?<key>(\w)+) (?<flags>[0-9]+) (?<exptime>[0-9]+) (?<bytes>[0-9]+)(?<noreply> noreply)?\n/
+        define :replace, /^replace (?<key>(\w)+) (?<flags>[0-9]+) (?<exptime>[0-9]+) (?<bytes>[0-9]+)(?<noreply> noreply)?\n/
+    
+        define :append, /^append (?<key>(\w)+) (?<bytes>[0-9]+)(?<noreply> noreply)?\n/
+        define :prepend, /^prepend (?<key>(\w)+) (?<bytes>[0-9]+)(?<noreply> noreply)?\n/
+    
+        define :cas, /^cas (?<key>(\w)+) (?<flags>[0-9]+) (?<exptime>[0-9]+) (?<bytes>[0-9]+) (?<cas_id>[0-9]+)(?<noreply> noreply)?\n/
+
+        define :delete, /^delete (?<key>(\w)+)(?<noreply> noreply)?\n/
+
+        define :incr, /^incr (?<key>(\w)+) (?<value>[0-9]+)(?<noreply> noreply)?\n/
+        define :decr, /^decr (?<key>(\w)+) (?<value>[0-9]+)(?<noreply> noreply)?\n/
+
+        define :end, /END\n/
+    end
+end

data/lib/ruby-memcached/constants/Errors.rb

@@ -0,0 +1,11 @@
+require 'ruby-enum'
+
+module RubyMemcached
+    class Errors
+        include Ruby::Enum
+
+        define :error, "ERROR\r\n"
+        define :client_error, "CLIENT_ERROR %s\r\n"
+        define :server_error, "SERVER_ERROR %s\r\n"
+    end
+end

data/lib/ruby-memcached/constants/Responses.rb

@@ -0,0 +1,18 @@
+require 'ruby-enum'
+
+module RubyMemcached
+    class Responses
+        include Ruby::Enum
+    
+        define :stored, "STORED\n"
+        define :not_stored, "NOT_STORED\n"
+        define :exists, "EXISTS\n"
+        define :not_found, "NOT_FOUND\n"
+        define :deleted, "DELETED\n"
+
+        define :get, "VALUE %s %d %d\n%s\n"
+        define :gets, "VALUE %s %d %d %d\n%s\n"
+        
+        define :end, "END\n"
+    end
+end

data/lib/ruby-memcached/constants/ResponsesRegex.rb

@@ -0,0 +1,12 @@
+require 'ruby-enum'
+
+module RubyMemcached
+    class ResponsesRegex
+        include Ruby::Enum
+
+        define :get, /VALUE (?<key>(\w)+) (?<flags>[0-9]+) (?<bytes>[0-9]+)/
+        define :gets, /VALUE (?<key>(\w)+) (?<flags>[0-9]+) (?<bytes>[0-9]+) (?<cas_id>[0-9]+)/
+    
+        define :end, /END/
+    end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: ruby-memcached
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francisco Bongiovanni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-enum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+description: A simple memcached implementation for Moove-It code challenge
+email: Frantss.Bongiovanni@gmail.com
+executables:
+- memcached-client.rb
+- memcached-server.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/memcached-client.rb
+- bin/memcached-server.rb
+- lib/ruby-memcached.rb
+- lib/ruby-memcached/Client.rb
+- lib/ruby-memcached/Constants.rb
+- lib/ruby-memcached/Item.rb
+- lib/ruby-memcached/Memcached.rb
+- lib/ruby-memcached/Server.rb
+- lib/ruby-memcached/constants/Commands.rb
+- lib/ruby-memcached/constants/CommandsRegex.rb
+- lib/ruby-memcached/constants/Errors.rb
+- lib/ruby-memcached/constants/Responses.rb
+- lib/ruby-memcached/constants/ResponsesRegex.rb
+homepage: https://rubygems.org/gems/ruby-memcached
+licenses:
+- MIT
+metadata:
+  github_uri: https://github.com/Frantss/memcached-ruby
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Simple ruby memcached implementation
+test_files: []