moped 0.0.0.beta → 1.0.0.alpha

data/lib/moped/bson/extensions/symbol.rb

@@ -0,0 +1,25 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Symbol
+        module ClassMethods
+          def __bson_load__(io)
+            io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8').intern
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::SYMBOL
+          io << key
+          io << NULL_BYTE
+
+          str = to_s.force_encoding('utf-8').force_encoding('binary')
+          io << [str.bytesize+1].pack(INT32_PACK)
+          io << str
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/extensions/time.rb

@@ -0,0 +1,21 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module Time
+        module ClassMethods
+          def __bson_load__(io)
+            at(io.read(8).unpack(INT64_PACK)[0]/1000.0)
+          end
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::TIME
+          io << key
+          io << NULL_BYTE
+          io << [to_f * 1000].pack(INT64_PACK)
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/extensions/true_class.rb

@@ -0,0 +1,15 @@
+module Moped
+  module BSON
+    # @private
+    module Extensions
+      module TrueClass
+        def __bson_dump__(io, key)
+          io << Types::BOOLEAN
+          io << key
+          io << NULL_BYTE
+          io << Types::TRUE
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/max_key.rb

@@ -0,0 +1,21 @@
+module Moped
+  module BSON
+    class MaxKey
+      class << self
+        def ===(other)
+          other == self
+        end
+
+        def __bson_load__(io)
+          self
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::MAX_KEY
+          io << key
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/min_key.rb

@@ -0,0 +1,21 @@
+module Moped
+  module BSON
+    class MinKey
+      class << self
+        def ===(other)
+          other == self
+        end
+
+        def __bson_load__(io)
+          self
+        end
+
+        def __bson_dump__(io, key)
+          io << Types::MIN_KEY
+          io << key
+          io << NULL_BYTE
+        end
+      end
+    end
+  end
+end

data/lib/moped/bson/object_id.rb

@@ -0,0 +1,123 @@
+require "digest/md5"
+require "socket"
+
+module Moped
+  module BSON
+    class ObjectId
+
+      # Formatting string for outputting an ObjectId.
+      @@string_format = ("%02x" * 12).freeze
+
+      attr_reader :data
+
+      class << self
+        def from_string(string)
+          data = []
+          12.times { |i| data << string[i*2, 2].to_i(16) }
+          new data
+        end
+
+        def legal?(str)
+          !!str.match(/^[0-9a-f]{24}$/i)
+        end
+      end
+
+      def initialize(data = nil, time = nil)
+        if data
+          @data = data
+        elsif time
+          @data = @@generator.generate(time.to_i)
+        else
+          @data = @@generator.next
+        end
+      end
+
+      def ==(other)
+        BSON::ObjectId === other && data == other.data
+      end
+      alias eql? ==
+
+      def hash
+        data.hash
+      end
+
+      def to_s
+        @@string_format % data
+      end
+
+      # Return the UTC time at which this ObjectId was generated. This may
+      # be used instread of a created_at timestamp since this information
+      # is always encoded in the object id.
+      def generation_time
+        Time.at(@data.pack("C4").unpack("N")[0]).utc
+      end
+
+      class << self
+        def __bson_load__(io)
+          new io.read(12).unpack('C*')
+        end
+
+      end
+
+      def __bson_dump__(io, key)
+        io << Types::OBJECT_ID
+        io << key
+        io << NULL_BYTE
+        io << data.pack('C12')
+      end
+
+      # @api private
+      class Generator
+        def initialize
+          # Generate and cache 3 bytes of identifying information from the current
+          # machine.
+          @machine_id = Digest::MD5.digest(Socket.gethostname).unpack("C3")
+
+          @mutex = Mutex.new
+          @last_timestamp = nil
+          @counter = 0
+        end
+
+        # Return object id data based on the current time, incrementing a
+        # counter for object ids generated in the same second.
+        def next
+          now = Time.new.to_i
+
+          counter = @mutex.synchronize do
+            last_timestamp, @last_timestamp = @last_timestamp, now
+
+            if last_timestamp == now
+              @counter += 1
+            else
+              @counter = 0
+            end
+          end
+
+          generate(now, counter)
+        end
+
+        # Generate object id data for a given time using the provided +inc+.
+        def generate(time, inc = 0)
+          pid = Process.pid % 0xFFFF
+
+          [
+            time >> 24 & 0xFF, # 4 bytes time (network order)
+            time >> 16 & 0xFF,
+            time >> 8  & 0xFF,
+            time       & 0xFF,
+            @machine_id[0],   # 3 bytes machine
+            @machine_id[1],
+            @machine_id[2],
+            pid  >> 8  & 0xFF, # 2 bytes process id
+            pid        & 0xFF,
+            inc  >> 16 & 0xFF, # 3 bytes increment
+            inc  >> 8  & 0xFF,
+            inc        & 0xFF,
+          ]
+        end
+      end
+
+      @@generator = Generator.new
+    end
+  end
+end

data/lib/moped/bson/timestamp.rb

@@ -0,0 +1,15 @@
+module Moped
+  module BSON
+    class Timestamp < Struct.new(:seconds, :increment)
+      class << self
+        def __bson_load__(io)
+          new(*io.read(8).unpack('l2'))
+        end
+      end
+
+      def __bson_dump__(io, key)
+        io << [17, key, increment, seconds].pack('cZ*l2')
+      end
+    end
+  end
+end

data/lib/moped/bson/types.rb

@@ -0,0 +1,67 @@
+module Moped
+  module BSON
+
+    # @private
+    module Types
+      class CodeWithScope
+        def self.__bson_load__(io)
+          io.read 4 # swallow the length
+
+          code = io.read(*io.read(4).unpack(INT32_PACK)).chop!.force_encoding('utf-8')
+          scope = BSON::Document.deserialize(io)
+
+          Code.new code, scope
+        end
+      end
+
+      class Integer64
+        def self.__bson_load__(io)
+          io.read(8).unpack(INT64_PACK)[0]
+        end
+      end
+
+      MAP = {}
+      MAP[1]  = Float
+      MAP[2]  = String
+      MAP[3]  = Hash
+      MAP[4]  = Array
+      MAP[5]  = Binary
+      # MAP[6]  = undefined - deprecated
+      MAP[7]  = ObjectId
+      MAP[8]  = TrueClass
+      MAP[9]  = Time
+      MAP[10] = NilClass
+      MAP[11] = Regexp
+      # MAP[12] = db pointer - deprecated
+      MAP[13] = Code
+      MAP[14] = Symbol
+      MAP[15] = CodeWithScope
+      MAP[16] = Integer
+      MAP[17] = Timestamp
+      MAP[18] = Integer64
+      MAP[255] = MinKey
+      MAP[127] = MaxKey
+
+      FLOAT = 1.chr.freeze
+      STRING = 2.chr.freeze
+      HASH = 3.chr.freeze
+      ARRAY = 4.chr.freeze
+      BINARY = 5.chr.freeze
+      OBJECT_ID = 7.chr.freeze
+      BOOLEAN = 8.chr.freeze
+      TIME = 9.chr.freeze
+      NULL = 10.chr.freeze
+      REGEX = 11.chr.freeze
+      CODE = 13.chr.freeze
+      SYMBOL = 14.chr.freeze
+      CODE_WITH_SCOPE = 15.chr.freeze
+      INT32 = 16.chr.freeze
+      INT64 = 18.chr.freeze
+      MAX_KEY = 127.chr.freeze
+      MIN_KEY = 255.chr.freeze
+
+      TRUE = 1.chr.freeze
+
+    end
+  end
+end

data/lib/moped/cluster.rb

@@ -0,0 +1,193 @@
+module Moped
+
+  # @api private
+  #
+  # The internal class managing connections to both a single node and replica
+  # sets.
+  #
+  # @note Though the socket class itself *is* threadsafe, the cluster presently
+  #   is not. This means that in the course of normal operations sessions can be
+  #   shared across threads, but in failure modes (when a resync is required),
+  #   things can possibly go wrong.
+  class Cluster
+
+    # @return [Array] the user supplied seeds
+    attr_reader :seeds
+
+    # @return [Boolean] whether this is a direct connection
+    attr_reader :direct
+
+    # @return [Array] all available nodes
+    attr_reader :servers
+
+    # @return [Array] seeds gathered from cluster discovery
+    attr_reader :dynamic_seeds
+
+    # @param [Array] seeds an array of host:port pairs
+    # @param [Boolean] direct (false) whether to connect directly to the hosts
+    # provided or to find additional available nodes.
+    def initialize(seeds, direct = false)
+      @seeds  = seeds
+      @direct = direct
+
+      @servers = []
+      @dynamic_seeds = []
+    end
+
+    # @return [Array] available secondary nodes
+    def secondaries
+      servers.select(&:secondary?)
+    end
+
+    # @return [Array] available primary nodes
+    def primaries
+      servers.select(&:primary?)
+    end
+
+    # @return [Array] all known addresses from user supplied seeds, dynamically
+    # discovered seeds, and active servers.
+    def known_addresses
+      [].tap do |addresses|
+        addresses.concat seeds
+        addresses.concat dynamic_seeds
+        addresses.concat servers.map { |server| server.address }
+      end.uniq
+    end
+
+    def remove(server)
+      servers.delete(server)
+    end
+
+    def reconnect
+      @servers = servers.map { |server| Server.new(server.address) }
+    end
+
+    def sync
+      known = known_addresses.shuffle
+      seen  = {}
+
+      sync_seed = ->(seed) do
+        server = Server.new seed
+
+        unless seen[server.resolved_address]
+          seen[server.resolved_address] = true
+
+          hosts = sync_server(server)
+
+          hosts.each do |host|
+            sync_seed[host]
+          end
+        end
+      end
+
+      known.each do |seed|
+        sync_seed[seed]
+      end
+
+      unless servers.empty?
+        @dynamic_seeds = servers.map(&:address)
+      end
+
+      true
+    end
+
+    def sync_server(server)
+      [].tap do |hosts|
+        socket = server.socket
+
+        if socket.connect
+          info = socket.simple_query Protocol::Command.new(:admin, ismaster: 1)
+
+          if info["ismaster"]
+            server.primary = true
+          end
+
+          if info["secondary"]
+            server.secondary = true
+          end
+
+          if info["primary"]
+            hosts.push info["primary"]
+          end
+
+          if info["hosts"]
+            hosts.concat info["hosts"]
+          end
+
+          if info["passives"]
+            hosts.concat info["passives"]
+          end
+
+          merge(server)
+
+        end
+      end.uniq
+    end
+
+    def merge(server)
+      previous = servers.find { |other| other == server }
+      primary = server.primary?
+      secondary = server.secondary?
+
+      if previous
+        previous.merge(server)
+      else
+        servers << server
+      end
+    end
+
+    # @param [:read, :write] mode the type of socket to return
+    # @return [Socket] a socket valid for +mode+ operations
+    def socket_for(mode)
+      sync unless primaries.any? || (secondaries.any? && mode == :read)
+
+      server = nil
+      while primaries.any? || (secondaries.any? && mode == :read)
+        if mode == :write || secondaries.empty?
+          server = primaries.sample
+        else
+          server = secondaries.sample
+        end
+
+        if server
+          socket = server.socket
+          socket.connect unless socket.connection
+
+          if socket.alive?
+            break server
+          else
+            remove server
+          end
+        end
+      end
+
+      unless server
+        raise Errors::ConnectionFailure.new("Could not connect to any primary or secondary servers")
+      end
+
+      socket = server.socket
+      socket.apply_auth auth
+      socket
+    end
+
+    # @return [Hash] the cached authentication credentials for this cluster.
+    def auth
+      @auth ||= {}
+    end
+
+    # Log in to +database+ with +username+ and +password+. Does not perform the
+    # actual log in, but saves the credentials for later authentication on a
+    # socket.
+    def login(database, username, password)
+      auth[database.to_s] = [username, password]
+    end
+
+    # Log out of +database+. Does not perform the actual log out, but will log
+    # out when the socket is used next.
+    def logout(database)
+      auth.delete(database.to_s)
+    end
+
+  end
+
+end