Method: Dalli::Client#get_multi

Defined in:
lib/dalli/client.rb

#get_multi(*keys) ⇒ Object

Fetch multiple keys efficiently. Returns a hash of { ‘key’ => ‘value’, ‘key2’ => ‘value1’ }



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/dalli/client.rb', line 59

def get_multi(*keys)
  return {} if keys.empty?
  options = nil
  options = keys.pop if keys.last.is_a?(Hash) || keys.last.nil?
  ring.lock do
    begin
      servers = self.servers_in_use = Set.new

      keys.flatten.each do |key|
        begin
          perform(:getkq, key)
        rescue DalliError, NetworkError => e
          Dalli.logger.debug { e.inspect }
          Dalli.logger.debug { "unable to get key #{key}" }
        end
      end

      values = {}
      return values if servers.empty?

      servers.each do |server|
        next unless server.alive?
        begin
          server.multi_response_start
        rescue DalliError, NetworkError => e
          Dalli.logger.debug { e.inspect }
          Dalli.logger.debug { "results from this server will be missing" }
          servers.delete(server)
        end
      end

      start = Time.now
      loop do
        # remove any dead servers
        servers.delete_if { |s| s.sock.nil? }
        break if servers.empty?

        # calculate remaining timeout
        elapsed = Time.now - start
        timeout = servers.first.options[:socket_timeout]
        if elapsed > timeout
          readable = nil
        else
          sockets = servers.map(&:sock)
          readable, _ = IO.select(sockets, nil, nil, timeout - elapsed)
        end

        if readable.nil?
          # no response within timeout; abort pending connections
          servers.each do |server|
            puts "Abort!"
            server.multi_response_abort
          end
          break

        else
          readable.each do |sock|
            server = sock.server

            begin
              server.multi_response_nonblock.each do |key, value|
                values[key_without_namespace(key)] = value
              end

              if server.multi_response_completed?
                servers.delete(server)
              end
            rescue NetworkError
              servers.delete(server)
            end
          end
        end
      end

      values
    ensure
      self.servers_in_use = nil
    end
  end
end