Class: RedisClient::Cluster

Inherits:
Object
  • Object
show all
Defined in:
lib/redis_client/cluster.rb,
lib/redis_client/cluster/node.rb,
lib/redis_client/cluster/errors.rb,
lib/redis_client/cluster/router.rb,
lib/redis_client/cluster/command.rb,
lib/redis_client/cluster/pub_sub.rb,
lib/redis_client/cluster/node_key.rb,
lib/redis_client/cluster/pipeline.rb,
lib/redis_client/cluster/transaction.rb,
lib/redis_client/cluster/concurrent_worker.rb,
lib/redis_client/cluster/node/primary_only.rb,
lib/redis_client/cluster/key_slot_converter.rb,
lib/redis_client/cluster/node/replica_mixin.rb,
lib/redis_client/cluster/node/random_replica.rb,
lib/redis_client/cluster/normalized_cmd_name.rb,
lib/redis_client/cluster/node/latency_replica.rb,
lib/redis_client/cluster/concurrent_worker/none.rb,
lib/redis_client/cluster/concurrent_worker/pooled.rb,
lib/redis_client/cluster/concurrent_worker/on_demand.rb,
lib/redis_client/cluster/node/random_replica_or_primary.rb

Defined Under Namespace

Modules: ConcurrentWorker, KeySlotConverter, NodeKey Classes: AmbiguousNodeError, Command, ErrorCollection, InitialSetupError, Node, NodeMightBeDown, NormalizedCmdName, OrchestrationCommandNotSupported, Pipeline, PubSub, Router, Transaction

Constant Summary collapse

ZERO_CURSOR_FOR_SCAN = 
'0'
ERR_ARG_NORMALIZATION = 
->(arg) { Array[arg].flatten.reject { |e| e.nil? || (e.respond_to?(:empty?) && e.empty?) } }

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config, pool: nil, concurrency: nil, **kwargs) ⇒ Cluster

Returns a new instance of Cluster.



15
16
17
18
19
20
 
# File 'lib/redis_client/cluster.rb', line 15

def initialize(config, pool: nil, concurrency: nil, **kwargs)
  @config = config
  @concurrent_worker = ::RedisClient::Cluster::ConcurrentWorker.create(**(concurrency || {}))
  @router = ::RedisClient::Cluster::Router.new(config, @concurrent_worker, pool: pool, **kwargs)
  @command_builder = config.command_builder
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, **kwargs, &block) ⇒ Object (private) 



111
112
113
114
115
116
117
118
119
 
# File 'lib/redis_client/cluster.rb', line 111

def method_missing(name, *args, **kwargs, &block)
  if @router.command_exists?(name)
    args.unshift(name)
    command = @command_builder.generate(args, kwargs)
    return @router.send_command(:call_v, command, &block)
  end

  super
end

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



13
14
15
 
# File 'lib/redis_client/cluster.rb', line 13

def config
  @config
end

Instance Method Details

#blocking_call(timeout, *args, **kwargs, &block) ⇒ Object 



46
47
48
49
 
# File 'lib/redis_client/cluster.rb', line 46

def blocking_call(timeout, *args, **kwargs, &block)
  command = @command_builder.generate(args, kwargs)
  @router.send_command(:blocking_call_v, command, timeout, &block)
end

#blocking_call_v(timeout, command, &block) ⇒ Object 



51
52
53
54
 
# File 'lib/redis_client/cluster.rb', line 51

def blocking_call_v(timeout, command, &block)
  command = @command_builder.generate(command)
  @router.send_command(:blocking_call_v, command, timeout, &block)
end

#call(*args, **kwargs, &block) ⇒ Object 



26
27
28
29
 
# File 'lib/redis_client/cluster.rb', line 26

def call(*args, **kwargs, &block)
  command = @command_builder.generate(args, kwargs)
  @router.send_command(:call_v, command, &block)
end

#call_once(*args, **kwargs, &block) ⇒ Object 



36
37
38
39
 
# File 'lib/redis_client/cluster.rb', line 36

def call_once(*args, **kwargs, &block)
  command = @command_builder.generate(args, kwargs)
  @router.send_command(:call_once_v, command, &block)
end

#call_once_v(command, &block) ⇒ Object 



41
42
43
44
 
# File 'lib/redis_client/cluster.rb', line 41

def call_once_v(command, &block)
  command = @command_builder.generate(command)
  @router.send_command(:call_once_v, command, &block)
end

#call_v(command, &block) ⇒ Object 



31
32
33
34
 
# File 'lib/redis_client/cluster.rb', line 31

def call_v(command, &block)
  command = @command_builder.generate(command)
  @router.send_command(:call_v, command, &block)
end

#close ⇒ Object 



103
104
105
106
107
 
# File 'lib/redis_client/cluster.rb', line 103

def close
  @concurrent_worker.close
  @router.close
  nil
end

#hscan(key, *args, **kwargs, &block) ⇒ Object 



73
74
75
76
 
# File 'lib/redis_client/cluster.rb', line 73

def hscan(key, *args, **kwargs, &block)
  node = @router.assign_node(['HSCAN', key])
  @router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
end

#inspect ⇒ Object 



22
23
24
 
# File 'lib/redis_client/cluster.rb', line 22

def inspect
  "#<#{self.class.name} #{@router.node_keys.join(', ')}>"
end

#multi(watch: nil, &block) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/redis_client/cluster.rb', line 92

def multi(watch: nil, &block)
  ::RedisClient::Cluster::Transaction
    .new(@router, @command_builder)
    .find_node(&block)
    .multi(watch: watch, &block)
end

#pipelined {|pipeline| ... } ⇒ Object

Yields:

  • (pipeline) 


83
84
85
86
87
88
89
90
 
# File 'lib/redis_client/cluster.rb', line 83

def pipelined
  seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
  pipeline = ::RedisClient::Cluster::Pipeline.new(@router, @command_builder, @concurrent_worker, seed: seed)
  yield pipeline
  return [] if pipeline.empty?

  pipeline.execute
end

#pubsub ⇒ Object 



99
100
101
 
# File 'lib/redis_client/cluster.rb', line 99

def pubsub
  ::RedisClient::Cluster::PubSub.new(@router, @command_builder)
end

#scan(*args, **kwargs, &block) ⇒ Object

Raises:

  • (ArgumentError) 


56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/redis_client/cluster.rb', line 56

def scan(*args, **kwargs, &block)
  raise ArgumentError, 'block required' unless block

  seed = Random.new_seed
  cursor = ZERO_CURSOR_FOR_SCAN
  loop do
    cursor, keys = @router.scan('SCAN', cursor, *args, seed: seed, **kwargs)
    keys.each(&block)
    break if cursor == ZERO_CURSOR_FOR_SCAN
  end
end

#sscan(key, *args, **kwargs, &block) ⇒ Object 



68
69
70
71
 
# File 'lib/redis_client/cluster.rb', line 68

def sscan(key, *args, **kwargs, &block)
  node = @router.assign_node(['SSCAN', key])
  @router.try_delegate(node, :sscan, key, *args, **kwargs, &block)
end

#zscan(key, *args, **kwargs, &block) ⇒ Object 



78
79
80
81
 
# File 'lib/redis_client/cluster.rb', line 78

def zscan(key, *args, **kwargs, &block)
  node = @router.assign_node(['ZSCAN', key])
  @router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
end