moped 0.0.0.beta → 1.0.0.alpha

data/lib/moped/server.rb

@@ -0,0 +1,73 @@
+module Moped
+
+  # @api private
+  #
+  # The internal class for storing information about a server.
+  class Server
+
+    # @return [String] the original host:port address provided
+    attr_reader :address
+
+    # @return [String] the resolved host:port address
+    attr_reader :resolved_address
+
+    # @return [String] the resolved ip address
+    attr_reader :ip_address
+
+    # @return [Integer] the resolved port
+    attr_reader :port
+
+    attr_writer :primary
+    attr_writer :secondary
+
+    def initialize(address)
+      @address = address
+
+      host, port = address.split(":")
+      port = port ? port.to_i : 27017
+
+      ip_address = ::Socket.getaddrinfo(host, nil, ::Socket::AF_INET, ::Socket::SOCK_STREAM).first[3]
+
+      @primary = @secondary = false
+      @ip_address = ip_address
+      @port = port
+      @resolved_address = "#{ip_address}:#{port}"
+    end
+
+    def primary?
+      !!@primary
+    end
+
+    def secondary?
+      !!@secondary
+    end
+
+    def merge(other)
+      @primary = other.primary?
+      @secondary = other.secondary?
+
+      other.close
+    end
+
+    def close
+      if @socket
+        @socket.close
+        @socket = nil
+      end
+    end
+
+    def socket
+      @socket ||= Socket.new(ip_address, port)
+    end
+
+    def ==(other)
+      self.class === other && hash == other.hash
+    end
+    alias eql? ==
+
+    def hash
+      [ip_address, port].hash
+    end
+
+  end
+end

data/lib/moped/session.rb

@@ -0,0 +1,253 @@
+module Moped
+
+  # A session in moped is root for all interactions with a MongoDB server or
+  # replica set.
+  #
+  # It can talk to a single default database, or dynamically speak to multiple
+  # databases.
+  #
+  # @example Single database (console-style)
+  #   session = Moped::Session.new(["127.0.0.1:27017"])
+  #   session.use :moped
+  #   session[:users].find.one # => { name: "John" }
+  #
+  # @example Multiple databases
+  #   session = Moped::Session.new(["127.0.0.1:27017"])
+  #
+  #   session.with(database: :admin) do |admin|
+  #     admin.command ismaster: 1
+  #   end
+  #
+  #   session.with(database: :moped) do |moped|
+  #     moped[:users].find.one # => { name: "John" }
+  #   end
+  #
+  # @example Authentication
+  #
+  #   session = Moped::Session.new %w[127.0.0.1:27017],
+  #   session.with(database: "admin").login("admin", "s3cr3t")
+  #
+  class Session
+    extend Forwardable
+
+    # @return [Hash] this session's options
+    attr_reader :options
+
+    # @private
+    # @return [Cluster] this session's cluster
+    attr_reader :cluster
+
+    # @param [Array] seeds an of host:port pairs
+    # @param [Hash] options
+    # @option options [Boolean] :safe (false) ensure writes are persisted
+    # @option options [Hash] :safe ensure writes are persisted with the
+    #   specified safety level e.g., "fsync: true", or "w: 2, wtimeout: 5"
+    # @option options [Symbol, String] :database the database to use
+    # @option options [:strong, :eventual] :consistency (:eventual)
+    def initialize(seeds, options = {})
+      @cluster = Cluster.new(seeds)
+      @options = options
+      @options[:consistency] ||= :eventual
+    end
+
+    # @return [Boolean] whether the current session requires safe operations.
+    def safe?
+      !!safety
+    end
+
+    # Switch the session's current database.
+    #
+    # @example
+    #   session.use :moped
+    #   session[:people].     john, mary = session[:people].find.one # => { :name => "John" }
+    #
+    # @param [String] database the database to use
+    def use(database)
+      options[:database] = database
+      set_current_database database
+    end
+
+    # Create a new session with +options+ reusing existing connections.
+    #
+    # @example Change safe mode
+    #   session.with(safe: { w: 2 })[:people].insert(name: "Joe")
+    #
+    # @example Change safe mode with block
+    #   session.with(safe: { w: 2 }) do |session|
+    #     session[:people].insert(name: "Joe")
+    #   end
+    #
+    # @example Temporarily change database
+    #   session.with(database: "admin") do |admin|
+    #     admin.command ismaster: 1
+    #   end
+    #
+    # @example Copy between databases
+    #   session.use "moped"
+    #   session.with(database: "backup") do |backup|
+    #     session[:people].each do |person|
+    #       backup[:people].insert person
+    #     end
+    #   end
+    #
+    # @yieldparam [Moped::Session] session the new session
+    # @return [Moped::Session, Object] the new session, or the value returned
+    #   by the block if provided.
+    def with(options = {})
+      session = dup
+      session.options.update options
+
+      if block_given?
+        yield session
+      else
+        session
+      end
+    end
+
+    # Create a new session with +options+ and use new socket connections.
+    #
+    # @see #with
+    # @yieldparam [Moped::Session] session the new session
+    # @return [Moped::Session] the new session
+    def new(options = {})
+      session = with(options)
+      session.cluster.reconnect
+
+      if block_given?
+        yield session
+      else
+        session
+      end
+    end
+
+    # @method [](collection)
+    # Return +collection+ from the current database.
+    #
+    # @param (see Moped::Database#[])
+    # @return (see Moped::Database#[])
+    delegate :"[]" => :current_database
+
+    # @method command(command)
+    # Run +command+ on the current database.
+    #
+    # @param (see Moped::Database#command)
+    # @return (see Moped::Database#command)
+    delegate :command => :current_database
+
+    # @method drop
+    # Drop the current database.
+    #
+    # @param (see Moped::Database#drop)
+    # @return (see Moped::Database#drop)
+    delegate :drop => :current_database
+
+    # @method login(username, password)
+    # Log in with +username+ and +password+ on the current database.
+    #
+    # @param (see Moped::Database#login)
+    # @raise (see Moped::Database#login)
+    delegate :login => :current_database
+
+    # @method logout
+    # Log out from the current database.
+    #
+    # @param (see Moped::Database#logout)
+    # @raise (see Moped::Database#login)
+    delegate :logout => :current_database
+
+    # @private
+    def current_database
+      return @current_database if defined? @current_database
+
+      if database = options[:database]
+        set_current_database(database)
+      else
+        raise "No database set for session. Call #use or #with before accessing the database"
+      end
+    end
+
+    # @private
+    def simple_query(query)
+      query.limit = -1
+
+      query(query).documents.first
+    end
+
+    # @private
+    def query(query)
+      if options[:consistency] == :eventual
+        query.flags |= [:slave_ok] if query.respond_to? :flags
+        mode = :read
+      else
+        mode = :write
+      end
+
+      reply = socket_for(mode).execute(query)
+
+      reply.tap do |reply|
+        if reply.flags.include?(:query_failure)
+          raise Errors::QueryFailure.new(query, reply.documents.first)
+        end
+      end
+    end
+
+    # @private
+    def execute(op)
+      mode = options[:consistency] == :eventual ? :read : :write
+      socket = socket_for(mode)
+
+      if safe?
+        last_error = Protocol::Command.new(
+          "admin", { getlasterror: 1 }.merge(safety)
+        )
+
+        socket.execute(op, last_error).documents.first.tap do |result|
+          raise Errors::OperationFailure.new(
+            op, result
+          ) if result["err"] || result["errmsg"]
+        end
+      else
+        socket.execute(op)
+      end
+    end
+
+    private
+
+    # @return [Boolean, Hash] the safety level for this session
+    def safety
+      safe = options[:safe]
+
+      case safe
+      when false
+        false
+      when true
+        { safe: true }
+      else
+        safe
+      end
+    end
+
+    def socket_for(mode)
+      if options[:retain_socket]
+        @socket ||= cluster.socket_for(mode)
+      else
+        cluster.socket_for(mode)
+      end
+    end
+
+    def set_current_database(database)
+      @current_database = Database.new(self, database)
+    end
+
+    def dup
+      session = super
+      session.instance_variable_set :@options, options.dup
+
+      if defined? @current_database
+        session.send(:remove_instance_variable, :@current_database)
+      end
+
+      session
+    end
+  end
+end

data/lib/moped/socket.rb

@@ -0,0 +1,201 @@
+require "timeout"
+
+module Moped
+
+  # @api private
+  #
+  # The internal class wrapping a socket connection.
+  class Socket
+
+    # Thread-safe atomic integer.
+    class RequestId
+      def initialize
+        @mutex = Mutex.new
+        @id = 0
+      end
+
+      def next
+        @mutex.synchronize { @id += 1 }
+      end
+    end
+
+    attr_reader :connection
+
+    attr_reader :host
+    attr_reader :port
+
+    def initialize(host, port)
+      @host = host
+      @port = port
+
+      @mutex = Mutex.new
+      @request_id = RequestId.new
+    end
+
+    # @return [true, false] whether the connection was successful
+    # @note The connection timeout is currently just 0.5 seconds, which should
+    #   be sufficient, but may need to be raised or made configurable for
+    #   high-latency situations. That said, if connecting to the remote server
+    #   takes that long, we may not want to use the node any way.
+    def connect
+      return true if connection
+
+      Timeout::timeout 0.5 do
+        @connection = TCPSocket.new(host, port)
+      end
+    rescue Errno::ECONNREFUSED, Timeout::Error
+      return false
+    end
+
+    # @return [true, false] whether this socket connection is alive
+    def alive?
+      if connection
+        return false if connection.closed?
+
+        @mutex.synchronize do
+          if select([connection], nil, nil, 0)
+            !connection.eof? rescue false
+          else
+            true
+          end
+        end
+      else
+        false
+      end
+    end
+
+    # Execute the operations on the connection.
+    def execute(*ops)
+      instrument(ops) do
+        buf = ""
+
+        last = ops.each do |op|
+          op.request_id = @request_id.next
+          op.serialize buf
+        end.last
+
+        if Protocol::Query === last || Protocol::GetMore === last
+          length = nil
+
+          @mutex.synchronize do
+            connection.write buf
+
+            length, = connection.read(4).unpack('l<')
+
+            # Re-use the already allocated buffer used for writing the command.
+            connection.read(length - 4, buf)
+          end
+
+          parse_reply length, buf
+        else
+          @mutex.synchronize do
+            connection.write buf
+          end
+
+          nil
+        end
+      end
+    end
+
+    def parse_reply(length, data)
+      buffer = StringIO.new data
+
+      reply = Protocol::Reply.allocate
+
+      reply.length = length
+
+      reply.request_id,
+        reply.response_to,
+        reply.op_code,
+        reply.flags,
+        reply.cursor_id,
+        reply.offset,
+        reply.count = buffer.read(32).unpack('l4<q<l2<')
+
+      reply.documents = reply.count.times.map do
+        BSON::Document.deserialize(buffer)
+      end
+
+      reply
+    end
+
+    # Executes a simple (one result) query and returns the first document.
+    #
+    # @return [Hash] the first document in a result set.
+    def simple_query(query)
+      query = query.dup
+      query.limit = -1
+
+      execute(query).documents.first
+    end
+
+    # Manually closes the connection
+    def close
+      @mutex.synchronize do
+        connection.close if connection && !connection.closed?
+        @connection = nil
+      end
+    end
+
+    def auth
+      @auth ||= {}
+    end
+
+    def apply_auth(credentials)
+      return if auth == credentials
+      logouts = auth.keys - credentials.keys
+
+      logouts.each do |database|
+        logout database
+      end
+
+      credentials.each do |database, (username, password)|
+        login(database, username, password) unless auth[database] == [username, password]
+      end
+    end
+
+    def login(database, username, password)
+      getnonce = Protocol::Command.new(database, getnonce: 1)
+      result = simple_query getnonce
+
+      raise Errors::OperationFailure.new(getnonce, result) unless result["ok"] == 1
+
+      authenticate = Protocol::Commands::Authenticate.new(database, username, password, result["nonce"])
+      result = simple_query authenticate
+      raise Errors::OperationFailure.new(authenticate, result) unless result["ok"] == 1
+
+      auth[database.to_s] = [username, password]
+    end
+
+    def logout(database)
+      command = Protocol::Command.new(database, logout: 1)
+      result = simple_query command
+      raise Errors::OperationFailure.new(command, result) unless result["ok"] == 1
+      auth.delete(database.to_s)
+    end
+
+    def instrument(ops)
+      instrument_start = (logger = Moped.logger) && logger.debug? && Time.now
+      yield
+    ensure
+      log_operations(logger, ops, Time.now - instrument_start) if instrument_start && !$!
+    end
+
+    def log_operations(logger, ops, duration)
+      prefix  = "  MOPED: #{host}:#{port} "
+      indent  = " "*prefix.length
+      runtime = (" (%.1fms)" % duration)
+
+      if ops.length == 1
+        logger.debug prefix + ops.first.log_inspect + runtime
+      else
+        first, *middle, last = ops
+
+        logger.debug prefix + first.log_inspect
+        middle.each { |m| logger.debug indent + m.log_inspect }
+        logger.debug indent + last.log_inspect + runtime
+      end
+    end
+
+  end
+end