stn-dcell 0.16.0

data/lib/dcell/registries/cassandra_adapter.rb

@@ -0,0 +1,126 @@
+require 'cassandra'
+
+# create the keyspace / columnfamily with cqlsh
+#
+# create keyspace dcell
+#  with strategy_class='SimpleStrategy'
+#   and strategy_options:replication_factor=3;
+#
+# create columnfamily dcell (dcell_type ascii primary key);
+
+# not sure this is right yet ...
+# Keyspace "whatever" [
+#   ColumnFamily "dcell" {
+#     RowKey "nodes": {
+#       <nodeid>: <address>,
+#       <nodeid>: <address>,
+#       ...
+#     }
+#     RowKey "globals": {
+#       <key>: <marshal blob>,
+#       <key>: <marshal blob>,
+#       ...
+#     }
+#   }
+# ]
+#
+
+module DCell
+  module Registry
+    class CassandraAdapter
+      DEFAULT_KEYSPACE = "dcell"
+      DEFAULT_CF = "dcell"
+
+      def initialize(options)
+        # Convert all options to symbols :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+
+        keyspace = options[:keyspace] || DEFAULT_KEYSPACE
+        columnfamily = options[:columnfamily] || DEFAULT_CF
+
+        options[:servers] ||= []
+        options[:servers] << options[:server] if options[:server]
+        options[:servers] << "localhost:9160" unless options[:servers].any?
+
+        cass = Cassandra.new(keyspace, options[:servers])
+
+        @node_registry   = NodeRegistry.new(cass, columnfamily)
+        @global_registry = GlobalRegistry.new(cass, columnfamily)
+      end
+
+      def remove_node(node)
+        @node_registry.remove node
+      end
+
+      def clear_all_nodes
+        @node_registry.clear_all
+      end
+
+      def clear_globals
+        @global_registry.clear_all
+      end
+
+      class NodeRegistry
+        def initialize(cass, cf)
+          @cass = cass
+          @cf = cf
+        end
+
+        def get(node_id)
+          @cass.get @cf, "nodes", node_id
+        end
+
+        def set(node_id, addr)
+          @cass.insert @cf, "nodes", { node_id => addr }
+        end
+
+        def nodes
+          @cass.get(@cf, "nodes").keys
+        end
+
+        def remove(node)
+          @cass.remove @cf, "nodes", { node_id => node }
+        end
+
+        def clear_all
+          @cass.del @cf, "nodes"
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+
+      class GlobalRegistry
+        def initialize(cass, cf)
+          @cass = cass
+          @cf = cf
+        end
+
+        def get(key)
+          string = @cass.get @cf, "globals", key.to_s
+          Marshal.load string if string
+        end
+
+        # Set a global value
+        def set(key, value)
+          string = Marshal.dump value
+          @cass.insert @cf, "globals", { key.to_s => string }
+        end
+
+        # The keys to all globals in the system
+        def global_keys
+          @cass.get(@cf, "globals").keys
+        end
+
+        def clear_all
+          @cass.del @cf, "globals"
+        end
+      end
+
+      def get_global(key);        @global_registry.get(key) end
+      def set_global(key, value); @global_registry.set(key, value) end
+      def global_keys;            @global_registry.global_keys end
+    end
+  end
+end

data/lib/dcell/registries/mongodb_adapter.rb

@@ -0,0 +1,85 @@
+require 'mongoid'
+
+module DCell
+  module Registry
+    class MongodbAdapter
+      # Setup connection to mongodb
+      # config: path to mongoid configuration file
+      # env: mongoid environment to use
+      def initialize(options)
+        if options[:config]
+          Mongoid.load! options[:config], options[:env]
+        elsif options[:db]
+          Mongoid.connect_to options[:db]
+        end
+        if options[:options]
+          Mongoid.options = options[:options]
+        end
+      end
+
+      class DCellNode
+        include Mongoid::Document
+
+        field :key, type: String
+        field :value, type: Hash
+      end
+
+      class DCellGlobal
+        include Mongoid::Document
+
+        field :key, type: String
+        field :value, type: Hash
+      end
+
+      class Proxy
+        class << self
+          def set(storage, key, value)
+            entry = storage.find_or_create_by(key: key)
+            entry.value = {'v' => value}
+            entry.save!
+            value
+          end
+
+          def get(storage, key)
+            first = storage.where(key: key).first
+            if first and first.value
+              return first.value['v']
+            end
+            nil
+          end
+
+          def all(storage)
+            keys = []
+            storage.each do |entry|
+              keys << entry.key
+            end
+            keys
+          end
+
+          def remove(storage, key)
+            begin
+              storage.where(key: key).delete
+            rescue
+            end
+          end
+
+          def clear_all(storage)
+            storage.delete_all
+          end
+        end
+      end
+
+      def get_node(node_id);       Proxy.get(DCellNode, node_id) end
+      def set_node(node_id, addr); Proxy.set(DCellNode, node_id, addr) end
+      def nodes;                   Proxy.all(DCellNode) end
+      def remove_node(node_id);    Proxy.remove(DCellNode, node_id) end
+      def clear_all_nodes;         Proxy.clear_all(DCellNode) end
+
+      def get_global(key);         Proxy.get(DCellGlobal, key) end
+      def set_global(key, value);  Proxy.set(DCellGlobal, key, value) end
+      def global_keys;             Proxy.all(DCellGlobal) end
+      def clear_globals;           Proxy.clear_all(DCellGlobal) end
+
+    end
+  end
+end

data/lib/dcell/registries/redis_adapter.rb

@@ -0,0 +1,95 @@
+require 'celluloid/redis'
+require 'redis/connection/celluloid'
+require 'redis-namespace'
+
+module DCell
+  module Registry
+    class RedisAdapter
+      def initialize(options)
+        # Convert all options to symbols :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+
+        @env = options[:env] || 'production'
+        @namespace = options[:namespace] || "dcell_#{@env}"
+
+        redis  = Redis.new options
+        @redis = Redis::Namespace.new @namespace, :redis => redis
+
+        @node_registry   = NodeRegistry.new(@redis)
+        @global_registry = GlobalRegistry.new(@redis)
+      end
+
+      def remove_node(node)
+        @node_registry.remove node
+      end
+
+      def clear_all_nodes
+        @node_registry.clear_all
+      end
+
+      def clear_globals
+        @global_registry.clear_all
+      end
+
+      class NodeRegistry
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def get(node_id)
+          @redis.hget 'nodes', node_id
+        end
+
+        def set(node_id, addr)
+          @redis.hset 'nodes', node_id, addr
+        end
+
+        def nodes
+          @redis.hkeys 'nodes'
+        end
+
+        def remove(node)
+          @redis.hdel 'nodes', node
+        end
+
+        def clear_all
+          @redis.del 'nodes'
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.nodes end
+
+      class GlobalRegistry
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def get(key)
+          string = @redis.hget 'globals', key.to_s
+          Marshal.load string if string
+        end
+
+        # Set a global value
+        def set(key, value)
+          string = Marshal.dump value
+          @redis.hset 'globals', key.to_s, string
+        end
+
+        # The keys to all globals in the system
+        def global_keys
+          @redis.hkeys 'globals'
+        end
+
+        def clear_all
+          @redis.del 'globals'
+        end
+      end
+
+      def get_global(key);        @global_registry.get(key) end
+      def set_global(key, value); @global_registry.set(key, value) end
+      def global_keys;            @global_registry.global_keys end
+    end
+  end
+end

data/lib/dcell/registries/zk_adapter.rb

@@ -0,0 +1,123 @@
+require 'zk'
+
+module DCell
+  module Registry
+    class ZkAdapter
+      PREFIX  = "/dcell"
+      DEFAULT_PORT = 2181
+
+      # Create a new connection to Zookeeper
+      #
+      # servers: a list of Zookeeper servers to connect to. Each server in the
+      #          list has a host/port configuration
+      def initialize(options)
+        # Stringify keys :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+        @env = options['env'] || 'production'
+        @base_path = "#{PREFIX}/#{@env}"
+
+        # Let them specify a single server instead of many
+        server = options['server']
+        if server
+          servers = [server]
+        else
+          servers = options['servers']
+          raise "no Zookeeper servers given" unless servers
+        end
+
+        # Add the default Zookeeper port unless specified
+        servers.map! do |server|
+          if server[/:\d+$/]
+            server
+          else
+            "#{server}:#{DEFAULT_PORT}"
+          end
+        end
+
+        @zk = ZK.new(*servers)
+        @node_registry = Registry.new(@zk, @base_path, :nodes, true)
+        @global_registry = Registry.new(@zk, @base_path, :globals, false)
+      end
+
+      class Registry
+        def initialize(zk, base_path, name, ephemeral)
+          @zk = zk
+          @base_path = File.join(base_path, name.to_s)
+          @ephemeral = ephemeral
+          @zk.mkdir_p @base_path
+          @events = {}
+        end
+
+        def register(key)
+          path = "#{@base_path}/#{key}"
+          @events[path] ||= @zk.register(path) do |event|
+            key = event.path.match(/#{@base_path}\/(\w+)/)[1]
+            @events[event.path].unsubscribe
+            @events[event.path] = nil
+            if event.node_changed?
+              Celluloid::logger.debug "zk callback: node changed!"
+              Node.update(key)
+            end
+            if event.node_deleted?
+              Celluloid::logger.debug "zk callback: node deleted!"
+              Node.remove(key)
+            end
+
+          end
+        end
+
+        def get(key)
+          register(key)
+          result, _ = @zk.get("#{@base_path}/#{key}", watch: true)
+          Marshal.load result
+        rescue ZK::Exceptions::NoNode
+        end
+
+        def set(key, value)
+          register(key)
+          path = "#{@base_path}/#{key}"
+          string = Marshal.dump value
+          @zk.set path, string
+        rescue ZK::Exceptions::NoNode
+          @zk.create path, string, :ephemeral => @ephemeral
+        end
+
+        def all
+          @zk.children @base_path
+        end
+
+        def remove(key)
+          keys.each do |key|
+            path = "#{@base_path}/#{key}"
+            @zk.delete path
+          end
+        end
+
+        def clear_all
+          # delete znodes so any registered
+          # callback is triggered
+          all.each do |key|
+            remove key
+          end
+          @events.values.compact.each(&:unsubscribe)
+          @events.clear
+          @zk.rm_rf @base_path
+          @zk.mkdir_p @base_path
+        end
+      end
+
+      def get_node(node_id);       @node_registry.get(node_id) end
+      def set_node(node_id, addr); @node_registry.set(node_id, addr) end
+      def nodes;                   @node_registry.all end
+      def remove_node(node_id);    @node_registry.clear(node_id) end
+      def clear_all_nodes;         @node_registry.clear_all end
+
+      def get_global(key);        @global_registry.get(key) end
+      def set_global(key, value); @global_registry.set(key, value) end
+      def global_keys;            @global_registry.all end
+      def clear_globals;          @global_registry.clear_all end
+
+    end
+  end
+end

data/lib/dcell/responses.rb

@@ -0,0 +1,16 @@
+module DCell
+  # Responses to calls
+  class Response
+    attr_reader :request_id, :value
+
+    def initialize(request_id, value)
+      @request_id, @value = request_id, value
+    end
+  end
+
+  # Request successful
+  class SuccessResponse < Response; end
+
+  # Request failed
+  class ErrorResponse < Response; end
+end