dr-rubbis 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b71d14548833154a78afeaff9ac69af91456087d
+  data.tar.gz: fc4363db29d51f7d7f69870bebf1ba47e10ff397
+SHA512:
+  metadata.gz: 9a79f73e98b8bf455d7e8522012b4bb4b0100d466da80d9fe242a87de20cf1161758c17a4ed504f0ca0742743ff96f694c77a9362d34916f397cdaf6461e5d0f
+  data.tar.gz: 0625170d31443d3ce56152c741350ff9dce243d4519f90949bf5c20e3c65ae7f23a6b9f2b1e62721d52ba7f71e951e3eb0e966cc32fd993947f8b4a748f912c4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'redis'
+gem 'rspec'	

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    redis (3.3.3)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  redis
+  rspec
+
+BUNDLED WITH
+   1.15.3

data/README.md

@@ -0,0 +1 @@
+A tutorial for ruby. Implementing redis in ruby.

data/bin/rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/server

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+port = ARGV.fetch(0, 6379)
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubbis/server'
+
+Rubbis::Server.new(port: port, aof_file: "./data.aof").listen

data/lib/dr_rubbis.rb

@@ -0,0 +1,3 @@
+# $LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+require 'rubbis/server'

data/lib/rubbis/handler.rb

@@ -0,0 +1,78 @@
+require 'rubbis/transaction'
+module Rubbis
+    class Handler
+
+        attr_reader :client, :buffer, :tx, :server
+
+        def initialize(socket, server)
+            @client = socket
+            @server = server
+            @buffer = ""
+            reset_tx!
+        end
+
+        def reset_tx!
+            @tx = Transaction.new
+        end
+
+        def process!(state)
+            buffer << client.read_nonblock(1024)
+            cmds, processed = Rubbis::Protocol.unmarshal(buffer)
+
+            @buffer = buffer[processed..-1]
+
+            cmds.each do |cmd|
+                response = if tx.active?
+                    case cmd[0].downcase
+                    when 'exec'
+                        result = tx.buffer.map do |cmd|
+                            dispatch state, cmd
+                        end unless tx.dirty?
+                        reset_tx!
+                        result
+                    else
+                        tx.queue cmd
+                        :queued
+                    end
+                else
+                    dispatch state, cmd
+                end
+
+                unless response == :block
+                    respond! response
+                end
+
+                state.process_list_watches!
+            end
+        end
+
+        def respond!(response)
+            if active?
+                server.commit!
+                client.write Rubbis::Protocol.marshal(response) 
+            end
+        end
+
+        def active?
+            client
+        end
+
+        def disconnect!(state)
+            state.unsubscribe_all(self)
+            @client = nil
+        end
+
+        def dispatch(state, cmd)
+            case cmd[0].downcase
+            when 'bgsave' then server.bgsave; :ok
+            when 'multi' then tx.start!; :ok
+            when 'watch' then
+                curr_tx = tx
+                state.watch(cmd[1]) {
+                    tx.dirty! if curr_tx == tx
+                }
+            else state.apply_command(self, cmd)
+            end
+        end
+    end
+end

data/lib/rubbis/protocol.rb

@@ -0,0 +1,63 @@
+module Rubbis
+    class Protocol
+        class ProtocolError < RuntimeError; end
+
+        class << self
+            def marshal(ruby)
+                case ruby
+                when Symbol then "+#{ruby.to_s.upcase}\r\n"
+                when nil then "$-1\r\n"
+                when Integer then ":#{ruby}\r\n"
+                when String then "$#{ruby.length}\r\n#{ruby}\r\n"
+                when Error then "-ERR #{ruby.message}\r\n"
+                when Array then "*#{ruby.length}\r\n#{ruby.map {|x| marshal(x)}.join}"
+                else raise "Dont know how to marshal #{ruby}"       
+                end 
+            end
+            
+            def unmarshal(data)
+                io = StringIO.new(data)
+                result = []
+                processed = 0
+                begin
+                    loop do
+                        header = safe_readline(io)
+
+                        raise ProtocolError unless header[0] == '*'
+
+                        n = header[1..-1].to_i
+
+                        result << n.times.map do
+                            raise ProtocolError unless io.readpartial(1) == '$'
+
+                            length = safe_readline(io).to_i
+                            safe_readpartial(io, length).tap do
+                                safe_readline(io)
+                            end
+                        end
+
+                        processed = io.pos
+                    end
+                rescue ProtocolError
+                    processed = io.pos
+                rescue EOFError
+                end
+
+                [result, processed]
+            end
+
+            def safe_readline(io)
+                io.readline("\r\n").tap do |line|
+                    raise EOFError unless line.end_with?("\r\n")
+                end
+            end
+
+            def safe_readpartial(io, length)
+                io.readpartial(length).tap do |data|
+                    raise EOFError unless data.length == length
+                end
+            end
+
+        end
+    end
+end

data/lib/rubbis/server.rb

@@ -0,0 +1,166 @@
+require "socket"
+require 'stringio'
+require 'tempfile'
+
+require 'rubbis/protocol'
+require 'rubbis/state'
+require 'rubbis/handler'
+
+module Rubbis
+    class Server
+
+        class Clock
+            def now
+                Time.now.to_f
+            end
+
+            def sleep(x)
+                ::Kernel.sleep x
+            end
+        end
+
+        def initialize(opts = {})
+            @port = opts[:port]
+            @shutdown_pipe = IO.pipe
+            @clock = Clock.new
+            @state = State.new(@clock)
+            @server_file = opts[:server_file]
+            @aof_file = opts[:aof_file]
+        end
+
+        def bgsave
+            return unless server_file
+            begin
+                tmpf = Tempfile.new(File.basename(server_file))
+                tmpf.write state.serialize
+                tmpf.close
+                FileUtils.mv(tmpf, server_file)
+                :ok
+            ensure
+                if tmpf
+                    tmpf.close
+                    tmpf.unlink
+                end
+            end
+        end
+
+        def bgrewriteaof
+            return unless aof_file
+            begin
+                tmpf = Tempfile.new(File.basename(aof_file))
+                state.minimal_log.each do |cmd|
+                    tmpf.write Rubbis::Protocol.marshal(cmd)
+                end 
+
+                tmpf.close
+
+                command_log.close
+                FileUtils.mv(tmpf, aof_file)
+                @command_log = File.open(aof_file, 'a')
+                :ok
+            ensure
+                if tmpf
+                    tmpf.close
+                    tmpf.unlink
+                end
+            end
+        end
+
+        def commit!
+            return unless command_log
+
+            state.log.each do |cmd|
+                command_log.write Rubbis::Protocol.marshal(cmd)
+            end
+            command_log.fsync
+            state.log.clear
+        end
+
+        def check_background_processes!
+
+        end
+
+        def shutdown
+            shutdown_pipe[1].close
+        end
+
+        class AofClient < StringIO 
+            def write(*_)
+                # noop
+            end
+        end
+        def apply_log(contents)
+            Handler.new(AofClient.new(contents), self).process!(state)
+        end
+
+        def listen
+            readable = []
+            clients = {}
+            running = true
+
+            server = TCPServer.new(port)
+            
+            expire_pipe = IO.pipe
+            readable << server
+            readable << shutdown_pipe[0]
+            readable << expire_pipe[0]
+
+            @command_log = File.open(aof_file, 'a') if aof_file
+
+            if aof_file && File.exists?(aof_file)
+                apply_log File.read(aof_file)
+            elsif server_file && File.exists?(server_file)
+                @state.deserialize File.read(server_file)
+            end
+
+            timer_thread = Thread.new do
+                begin
+                    while running
+                        sleep 0.1
+                        expire_pipe[1].write '.'
+                    end
+                rescue Errno::EPIPE, IOError
+                end
+            end
+
+            while running
+                ready_to_read, _ = IO.select(readable + clients.keys)
+                ready_to_read.each do |socket|
+                    case socket
+                    when server
+                        child_socket = socket.accept_nonblock
+                        clients[child_socket] = Handler.new(child_socket, self)
+                    when shutdown_pipe[0]
+                        running = false
+                    when expire_pipe[0]
+                        state.expire_keys!
+                        check_background_processes!
+                    else
+                        begin
+                            clients[socket].process!(state)
+                        rescue EOFError
+                            handler = clients.delete(socket)
+                            handler.disconnect!(state)
+                            socket.close
+                        end
+                    end
+                end
+            end
+        ensure
+            running = false
+            (readable + clients.keys).each do |file|
+                file.close
+            end
+            expire_pipe[1].close if expire_pipe
+            timer_thread.join if timer_thread
+        end
+
+        private
+
+        attr_reader :shutdown_pipe, :state, :clock, :server_file, :aof_file, :command_log
+
+        def port
+            @port
+        end
+    end
+end