redis_ring 0.0.2 → 0.1.0

data/lib/redis_ring/slave_rpc.rb

@@ -0,0 +1,42 @@
+module RedisRing
+  class SlaveRPC
+
+    attr_reader :http_client
+
+    def initialize(http_client)
+      @http_client = http_client
+    end
+
+    def connection(host, port)
+      Connection.new(http_client, host, port)
+    end
+
+    class Connection
+
+      attr_reader :http_client, :host, :port
+
+      def initialize(http_client, host, port)
+        @http_client = http_client
+        @host = host
+        @port = port
+      end
+
+      def join
+        http_client.post(host, port, "/slave/join")
+      end
+
+      def status
+        JSON.parse(http_client.get(host, port, "/slave/status"))
+      end
+
+      def start_shard(shard_no)
+        http_client.post(host, port, "/slave/start_shard/#{shard_no}")
+      end
+
+      def stop_shard(shard_no)
+        http_client.post(host, port, "/slave/stop_shard/#{shard_no}")
+      end
+
+    end
+  end
+end

data/lib/redis_ring/version.rb

@@ -1,3 +1,3 @@
 module RedisRing
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/redis_ring/web_interface.rb

@@ -1,14 +1,75 @@
 module RedisRing
 
+  class WebInterfaceRunner
+
+    include  RedisRing::BackgroundThread
+
+    attr_reader :master, :slave
+
+    def initialize(port, master, slave)
+      @port = port
+      @master = master
+      @slave = slave
+    end
+
+    def do_work
+      handler = Rack::Handler.get("webrick")
+      handler.run(WebInterface, :Port => @port, :master => @master, :slave => @slave) do |server|
+        @server = server
+        WebInterface.set :master, master
+        WebInterface.set :slave, slave
+        WebInterface.set :running, true
+      end
+    end
+
+    def halt
+      super
+      @server.stop if @server
+    end
+
+  end
+
   class WebInterface < Sinatra::Base
 
+    def master
+      self.class.master
+    end
+
+    def slave
+      self.class.slave
+    end
+
     get "/" do
       "RedisRing is running"
     end
 
-    get "/shards" do
+    post "/master/node_joined/:node_id" do
+      master.node_joined(params[:node_id])
+      "OK"
+    end
+
+    get "/slave/status" do
       content_type :json
-      Application.instance.shards_hash.to_json
+      slave.status.to_json
+    end
+
+    post "/slave/join" do
+      slave.join
+      "OK"
+    end
+
+    post "/slave/start_shard/:shard_no" do
+      slave.start_shard(params[:shard_no].to_i)
+      "OK"
+    end
+
+    post "/slave/stop_shard/:shard_no" do
+      slave.stop_shard(params[:shard_no].to_i)
+      "OK"
+    end
+
+    class << self
+      attr_accessor :master, :slave
     end
 
   end

data/lib/redis_ring/zookeeper_connection.rb

@@ -0,0 +1,73 @@
+module RedisRing
+
+  class ZookeeperConnection
+
+    attr_reader :current_node
+
+    def initialize(host_name, base_port, zookeeper_address)
+      @host_name = host_name
+      @base_port = base_port
+      @zookeeper_address = zookeeper_address
+      @connected = false
+      @base_path = "/nodes"
+      @mutex = Mutex.new
+    end
+
+    def nodes_changed?
+      return true unless nodes_watcher
+      return nodes_watcher.completed?
+    end
+
+    def nodes
+      @nodes_watcher = Zookeeper::WatcherCallback.new
+      resp = zookeeper.get_children(:path => base_path, :watcher => nodes_watcher, :watcher_context => base_path)
+      return resp[:children].sort
+    end
+
+    def node_data(node)
+      resp = zookeeper.get(:path => "#{base_path}/#{node}")
+      data = resp[:data]
+      return data ? JSON.parse(data) : nil
+    end
+
+    def update_status(status)
+      zookeeper.set(:path => "#{base_path}/status", :data => status.to_json)
+    end
+
+    def connected?
+      @connected
+    end
+
+    def connect
+      @mutex.synchronize do
+        break if connected?
+
+        @zookeeper = Zookeeper.new(zookeeper_address)
+
+        if @zookeeper.state != Zookeeper::ZOO_CONNECTED_STATE
+          raise "Zookeeper not connected!"
+        end
+
+        resp = @zookeeper.create(:path => base_path)
+        #raise "Could not create base path" unless resp[:rc] == Zookeeper::ZOK
+
+        resp = @zookeeper.create(:path => "#{base_path}/node-", :ephemeral => true, :sequence => true, :data => current_node_data.to_json)
+        #raise "Could not create node" unless resp[:rc] == Zookeeper::ZOK
+
+        @current_node = resp[:path].gsub("#{base_path}/", '')
+
+        @connected = true
+      end
+    end
+
+    protected
+
+    attr_reader :zookeeper, :base_path, :nodes_watcher, :zookeeper_address, :host_name, :base_port
+
+    def current_node_data
+      {:host => host_name, :port => base_port}
+    end
+
+  end
+
+end

data/lib/redis_ring/zookeeper_observer.rb

@@ -0,0 +1,47 @@
+module RedisRing
+
+  class ZookeeperObserver
+
+    include RedisRing::BackgroundThread
+
+    attr_reader :master, :slave, :zookeeper_connection
+
+    def initialize(zookeeper_connection, master, slave)
+      @zookeeper_connection = zookeeper_connection
+      @master = master
+      @slave = slave
+      @current_master = nil
+    end
+
+    def do_work
+      on_node_list_changed(zookeeper_connection.nodes) if zookeeper_connection.nodes_changed?
+      sleep(0.1)
+    end
+
+    protected
+
+    def on_node_list_changed(new_nodes)
+      current_master = new_nodes.first
+
+      unless @current_master == current_master
+        @current_master = current_master
+
+        if current_master == zookeeper_connection.current_node
+          master.became_master
+        else
+          master.no_longer_is_master
+        end
+
+        current_master_data = zookeeper_connection.node_data(current_master)
+        slave.current_master_host = current_master_data["host"]
+        slave.current_master_port = current_master_data["port"]
+
+        puts "NEW MASTER IS: #{slave.current_master_host}:#{slave.current_master_port}"
+      end
+
+      master.nodes_changed(new_nodes)
+    end
+
+  end
+
+end

data/lib/redis_ring.rb

@@ -2,17 +2,28 @@ require 'socket'
 require 'yaml'
 require 'erb'
 require 'fileutils'
+require 'net/http'
 
 require 'sinatra'
 require 'json'
 require 'daemons'
+require 'zookeeper'
 
 require 'monkey_patches'
 
+require 'redis_ring/background_thread'
 require 'redis_ring/configuration'
 require 'redis_ring/shard_config'
 require 'redis_ring/shard'
+require 'redis_ring/http_client'
+require 'redis_ring/node'
 require 'redis_ring/application'
 require 'redis_ring/web_interface'
 require 'redis_ring/process_manager'
+require 'redis_ring/master'
+require 'redis_ring/master_rpc'
+require 'redis_ring/slave'
+require 'redis_ring/slave_rpc'
+require 'redis_ring/zookeeper_observer'
+require 'redis_ring/zookeeper_connection'
 require 'redis_ring/cli'

data/redis_ring.gemspec

@@ -17,9 +17,11 @@ Gem::Specification.new do |s|
   s.add_dependency 'sinatra'
   s.add_dependency 'json'
   s.add_dependency 'daemons-mikehale'
+  s.add_dependency 'zookeeper'
 
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'mocha'
+  s.add_development_dependency 'simplecov'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/cluster_builder.rb

@@ -0,0 +1,224 @@
+class ClusterBuilder
+
+  def initialize
+    yield self
+  end
+
+  def nodes
+    @nodes ||= {}
+  end
+
+  def node(node_id)
+    nodes[node_id] ||= NodeBuilder.new(node_id, self)
+  end
+
+  def node_ids
+    return nodes.keys.sort
+  end
+
+  def start_shard(node_id, shard_number)
+    start_shard_callbacks.each do |block|
+      block.call(node_id, shard_number)
+    end
+  end
+
+  def stop_shard(node_id, shard_number)
+    stop_shard_callbacks.each do |block|
+      block.call(node_id, shard_number)
+    end
+  end
+
+  def on_start_shard(&block)
+    start_shard_callbacks << block
+  end
+
+  def on_stop_shard(&block)
+    stop_shard_callbacks << block
+  end
+
+  def start_shard_callbacks
+    @start_shard_callbacks ||= []
+  end
+
+  def stop_shard_callbacks
+    @stop_shard_callbacks ||= []
+  end
+
+  def fake_provider
+    @fake_provider ||= FakeNodeProvider.new(self)
+  end
+
+  def fake_connection
+    @fake_connection ||= FakeConnection.new(self)
+  end
+
+  class FakeNodeProvider
+    def initialize(cluster_builder)
+      @cluster_builder = cluster_builder
+      @count = 0
+    end
+
+    def new(host, port)
+      result = @cluster_builder.nodes.detect{|_, node| node.get.host == host && node.get.port == port }
+      return result[1].get if result
+      return @cluster_builder.node("unknown-node-#{@count += 1}").host(host).port(port).reachable(false).get
+    end
+  end
+
+  class FakeConnection
+    def initialize(cluster_builder)
+      @cluster_builder = cluster_builder
+    end
+
+    def node_data(node_id)
+      return nil unless @cluster_builder.nodes.key?(node_id)
+      node = @cluster_builder.node(node_id).get
+      return {"host" => node.host, "port" => node.port}
+    end
+
+    def update_status(status)
+      @status = status
+    end
+  end
+
+  class NodeBuilder
+    def initialize(node_id, cluster_builder)
+      @node_id = node_id
+      @joined = true
+      @running_shards = []
+      @available_shards = {}
+      @host = "localhost"
+      @port = 6400
+      @reachable = true
+      @cluster_builder = cluster_builder
+    end
+
+    def host(str)
+      @host = str
+      self
+    end
+
+    def port(int)
+      @port = int
+      self
+    end
+
+    def reachable(bool)
+      @reachable = bool
+      self
+    end
+
+    def joined(bool)
+      @joined = bool
+      self
+    end
+
+    def running_shards(arr)
+      @running_shards = arr
+      self
+    end
+
+    def running_shard(shard)
+      @running_shards << shard unless @running_shards.include?(shard)
+      self
+    end
+
+    def not_running_shard(shard)
+      @running_shards.delete(shard)
+      self
+    end
+
+    def available_shards(hash)
+      @available_shards = hash
+      self
+    end
+
+    def available_shard(shard, timestamp)
+      @available_shards[shard] = timestamp
+      self
+    end
+
+    def not_available_shard(shard)
+      @available_shards.delete(shard)
+      self
+    end
+
+    def load_properties(node)
+      node.load(props)
+    end
+
+    def props
+      {
+        :host => @host,
+        :port => @port,
+        :node_id => @node_id,
+        :running_shards => @running_shards,
+        :available_shards => @available_shards,
+        :joined => @joined,
+        :reachable => @reachable,
+        :cluster_builder => @cluster_builder
+      }
+    end
+
+    def get
+      @node ||= FakeNode.new(self)
+    end
+  end
+
+  class FakeNode
+
+    attr_reader :host, :port, :node_id
+
+    def initialize(builder)
+      @builder = builder
+      @builder.load_properties(self)
+    end
+
+    def load(opts)
+      @joined = opts[:joined]
+      @running_shards = opts[:running_shards]
+      @available_shards = opts[:available_shards]
+      @reachable = opts[:reachable]
+      @host = opts[:host]
+      @port = opts[:port]
+      @node_id = opts[:node_id]
+      @cluster_builder = opts[:cluster_builder]
+    end
+
+    def joined?
+      @joined
+    end
+
+    def available_shards
+      @available_shards
+    end
+
+    def running_shards
+      @running_shards
+    end
+
+    def start_shard(shard_number)
+      ensure_reachable
+      @running_shards << shard_number unless @running_shards.include?(shard_number)
+      @cluster_builder.start_shard(@node_id, shard_number)
+    end
+
+    def stop_shard(shard_number)
+      ensure_reachable
+      @running_shards.delete(shard_number)
+      @cluster_builder.stop_shard(@node_id, shard_number)
+    end
+
+    def update_status!
+      @builder.load_properties(self)
+      ensure_reachable
+    end
+
+    protected
+
+    def ensure_reachable
+      raise "Node #{@node_id} #{@host}:#{@port} is not reachable!" unless @reachable
+    end
+  end
+
+end

data/spec/fakes/fake_http_client.rb

@@ -0,0 +1,39 @@
+class FakeHttpClient < RedisRing::HttpClient
+
+  def posts
+    @posts ||= []
+  end
+
+  def gets
+    @gets ||= []
+  end
+
+  def responses
+    @responses ||= Hash.new("OK")
+  end
+
+  def post(host, port, path, params = {})
+    url = uri(host, port, path, params).to_s
+    posts << url
+    return responses[url]
+  end
+
+  def get(host, port, path, params = {})
+    url = uri(host, port, path, params).to_s
+    gets << url
+    return responses[url]
+  end
+
+  def set_response(url, text)
+    responses[url] = text
+  end
+
+  def sent_post?(url)
+    posts.include?(url)
+  end
+
+  def sent_get?(url)
+    gets.include?(url)
+  end
+
+end

data/spec/fakes/fake_master_rpc.rb

@@ -0,0 +1,20 @@
+class FakeMasterRPC
+
+  def connection(host, port)
+    @connections ||= {}
+    @connections["#{host}:#{port}"] ||= Connection.new
+  end
+
+  class Connection
+
+    def nodes_loaded
+      @node_loaded ||= []
+    end
+
+    def node_loaded(node_id)
+      nodes_loaded << node_id
+    end
+
+  end
+
+end

data/spec/fakes/fake_node_provider.rb

@@ -0,0 +1,2 @@
+class FakeNodeProvider
+end

data/spec/fakes/fake_process_manager.rb

@@ -0,0 +1,19 @@
+class FakeProcessManager
+
+  def started_shards
+    @started_shards ||= []
+  end
+
+  def start_shard(shard)
+    started_shards << shard
+  end
+
+  def stopped_shards
+    @stopped_shards ||= []
+  end
+
+  def stop_shard(shard)
+    stopped_shards << shard
+  end
+
+end

data/spec/fakes/fake_slave_rpc.rb

@@ -0,0 +1,36 @@
+class FakeSlaveRPC
+
+  def connection(host, port)
+    @connections ||= {}
+    @connections["#{host}:#{port}"] ||= Connection.new
+  end
+
+  class Connection
+
+    def status=(val)
+      @status = val
+    end
+
+    def status
+      @status ||= {"joined" => false, "running_shards" => [], "available_shards" => {}}
+    end
+
+    def started_shards
+      @started_shards ||= []
+    end
+
+    def start_shard(shard_number)
+      started_shards << shard_number
+    end
+
+    def stopped_shards
+      @stopped_shards ||= []
+    end
+
+    def stop_shard(shard_number)
+      stopped_shards << shard_number
+    end
+
+  end
+
+end

data/spec/fakes/fake_zookeeper_connection.rb

@@ -0,0 +1,2 @@
+class FakeZookeeperConnection
+end

data/spec/redis_ring/application_spec.rb

@@ -2,22 +2,24 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 describe RedisRing::Application do
 
-  describe "#shards_hash" do
-    before(:each) do
-      RedisRing::Shard.any_instance.stubs(:fork_redis_server => stub(:start => true, :stop => true, :running? => true))
-      RedisRing::ShardConfig.any_instance.stubs(:save)
-      RedisRing::ShardConfig.any_instance.stubs(:alive? => true)
+  before(:each) do
+    @conf = RedisRing::Configuration.from_yml_file(File.expand_path("../../test.conf", __FILE__))
+    @app = RedisRing::Application.new(@conf)
+  end
+
+  it "should run shards" do
+    @app.start
+    sleep(1)
 
-      @application = RedisRing::Application.new(RedisRing::Configuration.new)
-      @application.start
-    end
+    @app.slave.join
+    sleep(3)
 
-    it "should return all shards" do
-      shard_hash = @application.shards_hash
+    @app.slave.running_shards.keys.sort.should == [0, 1, 2, 3]
+  end
 
-      shard_hash[:count].should == @application.configuration.ring_size
-      shard_hash[:shards].size.should == @application.configuration.ring_size
-    end
+  after(:each) do
+    @app.stop
+    @app.wait
   end
 
 end

data/spec/redis_ring/master_rpc_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe RedisRing::MasterRPC do
+
+  before(:each) do
+    @http_client = FakeHttpClient.new
+    @host = "example.com"
+    @port = 666
+    @rpc = RedisRing::MasterRPC.new(@http_client).connection(@host, @port)
+  end
+
+  describe :node_joined do
+    it "should post to node joined url" do
+      @rpc.node_loaded("some_node_id")
+
+      @http_client.sent_post?("http://example.com:666/master/node_joined/some_node_id").should be_true
+    end
+  end
+
+end