memcached-server 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b24344e4d59a83ed5efc916e5e162c045968e9e54bdac468138d082387cc518a
+  data.tar.gz: fae266a5d5a9cc51c311566fcb6b7632e8f26517cb672213095e443e33695001
+SHA512:
+  metadata.gz: 4695cc451824b4ecda4fa3d5b10bf20f3c4d45494f51b49fcdf3a8fe93cacddd4649f84fef49167a1809ac72f5db0debb2474a06bf726692a8fe53ece85d033f
+  data.tar.gz: ba52fb4818a83c87336352157a0cf6c8d02236ab8e11ad818c07a4c78f24f4aeedba3ca30329b1ce0599799de243f53b3669fea461f20c2619f16beda0b08958

data/bin/memcached-client

@@ -0,0 +1,32 @@
+#!/usr/bin/envy ruby
+
+require 'socket'
+require_relative '../lib/memcached-server.rb'
+
+# Command line arguments
+hostname = ARGV[0]
+port = ARGV[1]
+
+socket = TCPSocket.new(hostname, port)
+
+# Listener thread
+listener = Thread.new {
+  while line = socket.gets()
+    puts(line)
+  end
+}
+
+# Speaker thread
+speaker = Thread.new {
+  loop do
+      command = STDIN.gets()
+      socket.puts(command)
+      break if $_.match(MemcachedServer::Reply::END_) # $_ : the last input line of string by gets or readline. Thread and scope local.
+      sleep(0.1)
+  end
+}
+
+listener.join()
+speaker.join()
+
+socket.close()

data/bin/memcached-server

@@ -0,0 +1,14 @@
+#!/usr/bin/envy ruby
+
+require_relative '../lib/memcached-server.rb'
+
+# Command line arguments
+hostname = ARGV[0]
+port = ARGV[1]
+
+server = MemcachedServer::Server.new(hostname, port)
+puts ('Server running on port %d' % server.port)
+
+run = Thread.new {server.run()}
+
+run.join()

data/lib/memcached-server.rb

@@ -0,0 +1,4 @@
+require_relative './memcached-server/memcache.rb'
+require_relative './memcached-server/server.rb'
+require_relative './memcached-server/client.rb'
+require_relative './memcached-server/constants.rb'

data/lib/memcached-server/client.rb

@@ -0,0 +1,210 @@
+require 'socket'
+require_relative 'constants.rb'
+
+module MemcachedServer
+  
+  # Class that communicates with a MemcachedServer::Server
+  class Client
+
+    # The client socket hostname or IP address
+    #
+    # @return [String, ipaddress]
+    attr_reader :hostname
+    
+    # The client socket port
+    #
+    # @return [port]
+    attr_reader :port
+
+    def initialize(hostname, port)
+
+        @hostname = hostname
+        @port = port
+        @server = TCPSocket.new(hostname, port)
+
+    end
+
+    # Sends the server a set command
+    # 
+    # @param key [String] The key of the item to store
+    # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+    # @param exptime [Integer] The exptime of the Item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def set(key, flags, exptime, bytes, data_block)
+      command = "set #{key} #{flags} #{exptime} #{bytes}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+    # Sends the server an add command
+    # 
+    # @param key [String] The key of the item to store
+    # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+    # @param exptime [Integer] The exptime of the Item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def add(key, flags, exptime, bytes, data_block)
+      command = "add #{key} #{flags} #{exptime} #{bytes}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+
+    # Sends the server a replace command
+    # 
+    # @param key [String] The key of the item to store
+    # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+    # @param exptime [Integer] The exptime of the Item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def replace(key, flags, exptime, bytes, data_block)
+      command = "replace #{key} #{flags} #{exptime} #{bytes}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+    # Sends the server an append command
+    # 
+    # @param key [String] The key of the item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def append(key, bytes, data_block)
+      command = "append #{key} #{bytes}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+    # Sends the server a prepend command
+    # 
+    # @param key [String] The key of the item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def prepend(key, bytes, data_block)
+      command = "prepend #{key} #{bytes}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+    # Sends the server a cas command
+    # 
+    # @param key [String] The key of the item to store
+    # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+    # @param exptime [Integer] The exptime of the Item to store
+    # @param bytes [Integer] The byte size of <data_block>
+    # @param cas_id [Integer] Is a unique integer value
+    # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+    # @return [String] The reply that describes the result of the operation
+    def cas(key, flags, exptime, bytes, cas_id, data_block)
+      command = "cas #{key} #{flags} #{exptime} #{bytes} #{cas_id}\n#{data_block}\n"
+      @server.puts(command)
+
+      return @server.gets()
+    end
+
+    # Sends the server a get command
+    # 
+    # @param keys [[String]] The keys of the items to retrieve
+    # @return [[MemcachedServer::Item]] Array of the retrieved MemcachedServer::Item instances
+    def get(keys)
+      @server.puts("get #{keys}")
+
+      n = keys.split(' ').length()
+      retrieved = {}
+
+      n.times do
+        loop do
+
+          case @server.gets()
+
+          when ReplyFormat::GET
+
+            key = $~[:key]
+            flags = $~[:flags].to_i()
+            bytes = $~[:bytes].to_i()
+            data_block = @server.read(bytes + 1).chomp()
+
+            item = Item.new(key, flags, 0, bytes, data_block)
+            retrieved[key.to_sym] = item
+
+          when ReplyFormat::END_
+
+            break
+
+          else
+            
+            puts "Error\nServer: #{$_}"
+            break
+
+          end
+
+        end
+
+      end
+
+      return retrieved
+    end
+
+    # Sends the server a gets command
+    # 
+    # @param keys [[String]] The keys of the items to retrieve
+    # @return [[MemcachedServer::Item]] Array of the retrieved MemcachedServer::Item instances
+    def gets(keys)
+      @server.puts("gets #{keys}")
+
+      n = keys.split(' ').length()
+      retrieved = {}
+
+      n.times do
+
+        loop do
+
+          case @server.gets()
+          when ReplyFormat::GETS
+            key = $~[:key]
+            flags = $~[:flags].to_i()
+            bytes = $~[:bytes].to_i()
+            cas_id = $~[:cas_id].to_i()
+            data_block = @server.read(bytes + 1).chomp()
+
+            item = Item.new(key, flags, 0, bytes, data_block)
+            item.cas_id = cas_id
+            retrieved[key.to_sym] = item
+
+          when ReplyFormat::END_
+            break
+
+          else
+            puts "Error\nServer: #{$_}"
+            break
+
+          end
+
+        end
+
+      end
+
+      return retrieved
+    end
+
+    # Sends the server an end command
+    #  
+    # @return [String] The reply that describes the result of the operation
+    def end()
+      @server.puts('END')
+      return @server.gets()
+    end
+
+  end
+
+end

data/lib/memcached-server/constants.rb

@@ -0,0 +1,65 @@
+module MemcachedServer
+
+    module CommandFormat
+        # \w - A word character ([a-zA-Z0-9_])
+        # \d - A digit character ([0-9])
+
+        # Storage commands format
+        SET = /^(?<name>set) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply>noreply)?\n/.freeze
+        ADD = /^(?<name>add) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply>noreply)?\n/.freeze
+        REPLACE = /^(?<name>replace) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+)(?<noreply>noreply)?\n/.freeze
+        APPEND = /^(?<name>append) (?<key>(\w)+) (?<bytes>\d+)(?<noreply>noreply)?\n/.freeze
+        PREPEND = /^(?<name>prepend) (?<key>(\w)+) (?<bytes>\d+)(?<noreply>noreply)?\n/.freeze
+        CAS = /^(?<name>cas) (?<key>(\w)+) (?<flags>\d+) (?<exptime>\d+) (?<bytes>\d+) (?<cas_id>\d+)(?<noreply>noreply)?\n/.freeze
+
+        # Retrieval commands format
+        GET = /^(?<name>get) (?<keys>(\w|\p{Space})+)\n/.freeze
+        GETS = /^(?<name>gets) (?<keys>(\w|\p{Space})+)\n/.freeze
+
+        # End command format
+        END_ = /^(?<name>END)\n$/.freeze
+    end
+
+    module Reply
+
+        # To indicate success.
+        STORED = "STORED\n".freeze
+
+        # To indicate the data was not stored, but not because of an error. 
+        # This normally means that the condition for an "add" or a "replace" command wasn't met.
+        NOT_STORED = "NOT_STORED\n".freeze
+        
+        # To indicate that the item you are trying to store with a "cas" command has been modified since you last fetched it.
+        EXISTS = "EXISTS\n".freeze
+
+        # To indicate that the item you are trying to store with a "cas" command did not exist.
+        NOT_FOUND = "NOT_FOUND\n".freeze
+
+        # Each item sent by the server looks like this
+        GET = "VALUE %s %d %d\n%s\n".freeze
+        GETS = "VALUE %s %d %d %d\n%s\n".freeze
+
+        END_ = "END\n".freeze
+
+    end
+
+    module ReplyFormat
+
+        # Each item sent by the server has this format
+        GET = /VALUE (?<key>\w+) (?<flags>\d+) (?<bytes>\d+)/.freeze
+        GETS = /VALUE (?<key>\w+) (?<flags>\d+) (?<bytes>\d+) (?<cas_id>\d+)/.freeze
+
+        # To indicate the end of reply.
+        END_ = /END/.freeze
+        
+    end
+
+    module Error
+
+        ERROR = "ERROR\r\n".freeze
+        CLIENT_ERROR = "CLIENT_ERROR%s\r\n".freeze
+        SERVER_ERROR = "SERVER_ERROR%s\r\n".freeze
+        
+    end
+
+end

data/lib/memcached-server/item.rb

@@ -0,0 +1,101 @@
+module MemcachedServer
+
+    # Class that wraps up a Memcached Item
+    class Item
+
+        # The key under which the client asks to store the data
+        #
+        # @return [String]
+        attr_accessor :key
+
+        # Is an arbitrary unsigned integer (written out in decimal)
+        #
+        # @return [Integer]
+        attr_accessor :flags
+
+        # The expiration time
+        #
+        # @return [Integer]
+        attr_accessor :exptime
+
+        # The bite size of <data_block>
+        #
+        # @return [Integer]
+        attr_accessor :bytes
+
+        # Is a chunk of arbitrary 8-bit data of length <bytes>
+        #
+        # @return [Hash]
+        attr_accessor :data_block
+
+        # A unique integer value
+        #
+        # @return [Integer]
+        attr_accessor :cas_id
+
+        # A simple semaphore that can be used to coordinate access to shared data from multiple concurrent threads.
+        #
+        # @return [Mutex]
+        attr_accessor :lock
+
+        @@last_cas_id = 0
+
+        def initialize(key, flags, exptime, bytes, data_block)
+
+            @key = key
+            @flags = flags
+            @exptime = get_exptime(exptime)
+            @bytes = bytes
+            @data_block = data_block
+
+            @lock = Mutex.new()
+
+        end
+
+        # Gets the next cas_id value read from #last_cas_id class variable
+        # 
+        # @return [Integer] The next cas_id
+        def get_cas_id()
+
+            @lock.synchronize do
+
+                @@last_cas_id += 1
+                next_id = @@last_cas_id.dup()
+                
+                return next_id
+
+            end
+        end
+        
+        # Updates the MemcachedServer::Item #cas_id with the corresponding next value read from #last_cas_id class variable
+        def update_cas_id()
+
+            @cas_id = get_cas_id()
+
+        end
+
+        # Parses the exptime of the MemcachedServer::Item instance
+        # 
+        # @param exptime [Integer] The expiration time
+        # @return [Time, nil] The expiration time
+        def get_exptime(exptime)
+
+            return nil if exptime == 0
+            return Time.now().getutc() if exptime < 0
+            return Time.now().getutc() + exptime
+
+        end
+
+        # Checks if a MemcachedServer::Item instance is expired
+        # 
+        # @return [Boolean] true if it's expired and otherwise false
+        def expired?()
+
+            return true if (!@exptime.nil?()) && (Time.now().getutc() > @exptime)
+            return false
+
+        end
+
+    end
+    
+end

data/lib/memcached-server/memcache.rb

@@ -0,0 +1,195 @@
+require_relative './item.rb'
+require_relative './constants.rb'
+
+module MemcachedServer
+
+    # The class used to process Memcache commands and store the Memcache server data
+    class Memcache
+
+        # The Hash map used to store the Memcache server data
+        #
+        # @return [Hash]
+        attr_reader :storage
+
+        def initialize()
+
+            @storage = Hash.new()
+
+        end
+
+        # Deletes @storage items if they are expired 
+        def purge_keys()
+
+            @storage.delete_if { | key, item | item.expired? }
+
+        end
+
+        # Retrieves the items corresponding to the given keys from @storage
+        # 
+        # @param keys [[String]] Array that contains the keys of the items to retrieve
+        # @return [[MemcachedServer::Item]] Array of the retrieved MemcachedServer::Item instances
+        def get(keys)
+
+            purge_keys()
+
+            items = @storage.values_at(*keys)
+            return items
+
+        end
+
+        # Stores a MemcachedServer::Item, with the attributes recieved by param, in @storage 
+        # Depends on #store_item method
+        # 
+        # @param key [String] The key of the item to store
+        # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+        # @param exptime [Integer] The exptime of the Item to store
+        # @param bytes [Integer] The byte size of <data_block>
+        # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+        # @return [String] The reply that describes the result of the operation
+        def set(key, flags, exptime, bytes, data_block)
+
+            store_item(key, flags, exptime, bytes, data_block)
+            return Reply::STORED
+
+        end
+
+        # Stores a MemcachedServer::Item, with the attributes recieved by param, in @storage only if it isn't already stored
+        # Depends on #store_item method
+        # 
+        # @param key [String] The key of the item to store
+        # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+        # @param exptime [Integer] The exptime of the Item to store
+        # @param bytes [Integer] The byte size of <data_block>
+        # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+        # @return [String] The reply that describes the result of the operation
+        def add(key, flags, exptime, bytes, data_block)
+
+            purge_keys()
+            
+            return Reply::NOT_STORED if @storage.key?(key)
+            
+            store_item(key, flags, exptime, bytes, data_block)
+            return Reply::STORED
+
+        end
+
+        # Replaces a MemcachedServer::Item stored in @storage, with a new one with the attributes recieved by param
+        # Depends on #store_item method
+        # 
+        # @param key [String] The key of the item to store
+        # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+        # @param exptime [Integer] The exptime of the Item to store
+        # @param bytes [Integer] The byte size of <data_block>
+        # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+        # @return [String] The reply that describes the result of the operation
+        def replace(key, flags, exptime, bytes, data_block)
+            
+            return Reply::NOT_STORED unless @storage.key?(key)
+
+            store_item(key, flags, exptime, bytes, data_block)
+            return Reply::STORED
+
+        end
+        
+        # Appends <new_data> to a MemcachedServer::Item data_block that is stored in @storage with an associated <key>
+        # 
+        # @param key [String] The key of the item to store
+        # @param bytes [Integer] The byte size of <new_data>
+        # @param new_data [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+        # @return [String] The reply that describes the result of the operation
+        def append(key, bytes, new_data)
+
+            purge_keys()
+
+            return Reply::NOT_STORED unless @storage.key?(key)
+
+            item = @storage[key]
+            item.lock.synchronize do
+
+                item.data_block.concat(new_data)
+                item.bytes += bytes
+
+            end
+
+            item.update_cas_id()
+            return Reply::STORED
+
+        end
+
+        # Prepends <new_data> to a MemcachedServer::Item data_block that is stored in @storage with an associated <key>
+        # 
+        # @param key [String] The key of the item to store
+        # @param bytes [Integer] The byte size of <new_data>
+        # @param new_data [String] Is a chunk of arbitrary 8-bit data of length <bytes>
+        # @return [String] The reply that describes the result of the operation
+        def prepend(key, bytes, new_data)
+
+            purge_keys()
+
+            return Reply::NOT_STORED unless @storage.key?(key)
+
+            item = @storage[key]
+            item.lock.synchronize do 
+
+                item.data_block.prepend(new_data)
+                item.bytes += bytes
+
+            end
+
+            item.update_cas_id()
+            return Reply::STORED
+
+        end
+
+        # Check and set operation that stores a MemcachedServer::Item only if no one else has updated since it was last fetched
+        # Depends on #store_item method
+        # 
+        # @param key [String] The key of the item to store
+        # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+        # @param exptime [Integer] The exptime of the Item to store
+        # @param bytes [Integer] The byte size of <data_block>
+        # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes>
+        # @param cas_id [Integer] Is a unique integer value
+        # @return [String] The reply that describes the result of the operation
+        def cas(key, flags, exptime, bytes, cas_id, data_block)
+
+            purge_keys()
+
+            return Reply::NOT_FOUND unless @storage.key?(key)
+
+            item = @storage[key]
+            item.lock.synchronize do
+
+                return Reply::EXISTS if cas_id != item.cas_id
+
+            end
+        
+            store_item(key, flags, exptime, bytes, data_block)
+            return Reply::STORED
+
+        end
+
+        # Stores a MemcachedServer::Item, with the attributes recieved by param, in @storage
+        # Before storing the MemcachedServer::Item it updates it's cas_id
+        # 
+        # @param key [String] The key of the item to store
+        # @param flags [Integer] Is an arbitrary unsigned integer (written out in decimal)
+        # @param exptime [Integer] The exptime of the Item to store
+        # @param bytes [Integer] The byte size of <data_block>
+        # @param data_block [String] Is a chunk of arbitrary 8-bit data of length <bytes> 
+        # @return [String] The reply that describes the result of the operation
+        def store_item(key, flags, exptime, bytes, data_block)
+
+            item = Item.new(key, flags, exptime, bytes, data_block)
+            item.update_cas_id()
+            item.lock.synchronize do
+                
+                @storage.store(key, item) unless item.expired?()
+
+            end
+
+        end
+
+    end
+
+end

data/lib/memcached-server/server.rb

@@ -0,0 +1,189 @@
+require 'socket'
+require_relative './memcache.rb'
+require_relative './constants.rb'
+
+module MemcachedServer
+    
+    # Class that wraps up a Memcached server
+    class Server
+
+        # The server hostname or IP address
+        #
+        # @return [String, ipaddress]
+        attr_reader :hostname
+
+        # The server port
+        #
+        # @return [port]
+        attr_reader :port
+
+        # The Memcache object that implements the logic of the Memcache protocol
+        #
+        # @return [MemcachedServer::Memcache]
+        attr_reader :mc
+
+        def initialize(hostname, port)
+
+            @hostname = hostname
+            @port = port
+            @connection = TCPServer.new(hostname, port)
+            @mc = Memcache.new()
+            
+        end
+
+        # Starts the server
+        def run()
+            
+            begin
+                loop do
+                    Thread.start(@connection.accept()) do | connection |
+
+                        puts("New connection: #{connection.to_s}.")
+
+                        close = false
+                        while command = connection.gets()
+                            
+                            puts("Command: #{command} | Connection: #{connection.to_s}")
+
+                            valid_command = validate_command(command)
+                            if valid_command
+                                close = run_command(connection, valid_command)
+                            else 
+                                connection.puts(Error::CLIENT_ERROR % [" Undefined command. Please check the command syntax and try again."])
+                            end
+
+                            break if close
+
+                        end
+
+                        connection.puts(Reply::END_)
+                        connection.close()
+                        puts ("Connection closed to: #{connection}.")
+
+                    end
+
+                end
+            rescue => exception
+                error = Error::SERVER_ERROR % exception.message
+                connection.puts(error)
+            end
+        end
+
+        # Runs a valid memcache command
+        # 
+        # Depends on MemcachedServer::Memcache method names.
+        # In some cases, to make #send method work the MemcachedServer::Memcache 
+        # corresponding method must be equal to valid_command[:name] 
+        # 
+        # @param connection [TCPSocket] Client's socket
+        # @param valid_command [MatchData] It encapsulates all the results of a valid command pattern match
+        # @return [Boolean] false if valid_command[:name] != END else true
+        def run_command(connection, valid_command)
+
+            name = valid_command[:name]
+
+            case name
+            when 'set', 'add', 'replace'
+
+                key = valid_command[:key]
+                flags = valid_command[:flags].to_i
+                exptime = valid_command[:exptime].to_i
+                bytes = valid_command[:bytes].to_i
+                noreply = !valid_command[:noreply].nil?
+                data = self.read_bytes(connection, bytes)
+
+                reply = @mc.send(name.to_sym, key, flags, exptime, bytes, data)
+                connection.puts(reply) unless noreply
+
+                return false
+
+            when 'append', 'prepend'
+
+                key = valid_command[:key]
+                bytes = valid_command[:bytes].to_i
+                data = self.read_bytes(connection, bytes)
+
+                reply = @mc.send(name.to_sym, key, bytes, data)
+                connection.puts(reply) unless noreply
+
+                return false
+
+            when 'cas'
+
+                key = valid_command[:key]
+                flags = valid_command[:flags].to_i
+                exptime = valid_command[:exptime].to_i
+                bytes = valid_command[:bytes].to_i
+                noreply = !valid_command[:noreply].nil?
+                data = self.read_bytes(connection, bytes)
+                cas_id = valid_command[:cas_id].to_i()
+
+                reply = @mc.cas(key, flags, exptime, bytes, cas_id, data)
+                connection.puts(reply) unless noreply
+
+                return false
+                
+            when 'get'
+
+                keys = valid_command[:keys].split(' ')
+                items = @mc.get(keys)
+
+                for item in items
+                    connection.puts(Reply::GET % [item.key, item.flags, item.bytes, item.data_block]) if item
+                    connection.puts(Reply::END_)
+                end
+
+                return false
+
+            when 'gets'
+
+                keys = valid_command[:keys].split(' ')
+                items = @mc.get(keys)
+
+                for item in items
+                    connection.puts(Reply::GETS % [item.key, item.flags, item.bytes, item.cas_id, item.data_block]) if item
+                    connection.puts(Reply::END_)
+                end
+
+                return false
+
+            else
+                # END command stops run
+                return true
+                
+            end
+        end
+        
+        # Reads <bytes> bytes from <connection>
+        # 
+        # @param connection [TCPSocket] Client's socket
+        # @param bytes [Integer] The number of bytes to read
+        # @return [String] The message read
+        def read_bytes(connection, bytes)
+
+            return connection.read(bytes + 1).chomp()
+
+        end
+
+        # Validates a command.
+        # If the command isn't valid it returns nil.
+        # 
+        # @param command [String] A command to validate
+        # @return [MatchData, nil] It encapsulates all the results of a valid command pattern match
+        def validate_command(command)
+
+            valid_formats = CommandFormat.constants.map{| key | CommandFormat.const_get(key)}
+
+            valid_formats.each do | form |
+
+                valid_command = command.match(form)
+                return valid_command unless valid_command.nil?
+                
+            end
+
+            return nil
+        end
+
+    end
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: memcached-server
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- José Andrés Puglia Laca
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+description: A simple Memcached server (TCP/IP socket) that complies with the specified
+  protocol. Implemented in Ruby.
+email:
+- andrespuglia98@gmail.com
+executables:
+- memcached-server
+- memcached-client
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/memcached-client
+- bin/memcached-server
+- lib/memcached-server.rb
+- lib/memcached-server/client.rb
+- lib/memcached-server/constants.rb
+- lib/memcached-server/item.rb
+- lib/memcached-server/memcache.rb
+- lib/memcached-server/server.rb
+homepage: https://github.com/AndresPuglia98/memcached-server
+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: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: A simple Memcached server implemented in Ruby.
+test_files: []