Class: Etzetera::Client

Inherits:
Object
  • Object
show all
Includes:
Celluloid::IO
Defined in:
lib/etzetera/client.rb

Constant Summary collapse

API_ENDPOINT = 
'v2'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(servers = ['http://127.0.0.1:4001'], consistent = true, default_options = {}) ⇒ Client

Returns a new instance of Client.



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/etzetera/client.rb', line 15

def initialize(servers = ['http://127.0.0.1:4001'],
  consistent = true,
  default_options = {})

  self.servers            = servers
  self.consistent         = consistent

  opts = {}
  opts[:follow]           = true
  opts[:headers]          = {:accept => 'application/json'}
  opts[:response]         = :object
  opts[:socket_class]     = Celluloid::IO::TCPSocket
  opts[:ssl_socket_class] = Celluloid::IO::SSLSocket

  @default_options = ::HTTP::Options.new(default_options.merge(opts))
end

Instance Attribute Details

#consistent ⇒ Object

Returns the value of attribute consistent.



13
14
15
 
# File 'lib/etzetera/client.rb', line 13

def consistent
  @consistent
end

#servers ⇒ Object

Returns the value of attribute servers.



13
14
15
 
# File 'lib/etzetera/client.rb', line 13

def servers
  @servers
end

Instance Method Details

#acquire_lock(name, ttl) ⇒ Object 



81
82
83
 
# File 'lib/etzetera/client.rb', line 81

def acquire_lock(name, ttl)
  request(:post, lock_path(name), :form => {:ttl => ttl})
end

#compareAndDelete(key, prevValue) ⇒ Object 



77
78
79
 
# File 'lib/etzetera/client.rb', line 77

def compareAndDelete(key, prevValue)
  request(:delete, keys_path(key), :params => {:prevValue => prevValue})
end

#compareAndSwap(key, prevValue) ⇒ Object 



73
74
75
 
# File 'lib/etzetera/client.rb', line 73

def compareAndSwap(key, prevValue)
  request(:put, keys_path(key), :params => {:prevValue => prevValue})
end

#create(key, form, params = {}) ⇒ Object 



57
58
59
 
# File 'lib/etzetera/client.rb', line 57

def create(key, form, params = {})
  request(:put, keys_path(key), form: form, :params => params.merge({:prevExist => false}))
end

#delete(key, params = {}) ⇒ Object 



40
41
42
 
# File 'lib/etzetera/client.rb', line 40

def delete(key, params = {})
  request(:delete, keys_path(key), :params => params)
end

#delete_leader(clustername, name) ⇒ Object 



105
106
107
 
# File 'lib/etzetera/client.rb', line 105

def delete_leader(clustername, name)
  request(:delete, leader_path(clustername), :form => {:name => name})
end

#dir(dir, params = {}) ⇒ Object 



65
66
67
 
# File 'lib/etzetera/client.rb', line 65

def dir(dir, params = {})
  request(:get, keys_path(dir), :params => params.merge({:recursive => true}))
end

#get(key, params = {}) ⇒ Object 



32
33
34
 
# File 'lib/etzetera/client.rb', line 32

def get(key, params = {})
  request(:get, keys_path(key), :params => params)
end

#get_leader(clustername, params = {}) ⇒ Object 



101
102
103
 
# File 'lib/etzetera/client.rb', line 101

def get_leader(clustername, params = {})
  request(:get, leader_path(clustername), :params => params)
end

#release_lock(name, form) ⇒ Object 



89
90
91
 
# File 'lib/etzetera/client.rb', line 89

def release_lock(name, form)
  request(:delete, lock_path(name), :form => form)
end

#renew_lock(name, form) ⇒ Object 



85
86
87
 
# File 'lib/etzetera/client.rb', line 85

def renew_lock(name, form)
  request(:put, lock_path(name), :form => form)
end

#retrieve_lock(name, params) ⇒ Object 



93
94
95
 
# File 'lib/etzetera/client.rb', line 93

def retrieve_lock(name, params)
  request(:get, lock_path(name), :params => params)
end

#rmdir(dir, params = {}) ⇒ Object 



69
70
71
 
# File 'lib/etzetera/client.rb', line 69

def rmdir(dir, params = {})
  request(:delete, keys_path(dir), :params => {:recursive => true}.merge(params))
end

#set(key, form, params = {}) ⇒ Object 



36
37
38
 
# File 'lib/etzetera/client.rb', line 36

def set(key, form, params = {})
  request(:put, keys_path(key), form: form, :params => params)
end

#set_leader(clustername, name, ttl) ⇒ Object 



97
98
99
 
# File 'lib/etzetera/client.rb', line 97

def set_leader(clustername, name, ttl)
  request(:put, leader_path(clustername), :form => {:name => name, :ttl => ttl})
end

#stats(type) ⇒ Object 



109
110
111
 
# File 'lib/etzetera/client.rb', line 109

def stats(type)
  request(:get, stats_path(type))
end

#update(key, form, params = {}) ⇒ Object 



61
62
63
 
# File 'lib/etzetera/client.rb', line 61

def update(key, form, params = {})
  request(:put, keys_path(key), form: form, :params => params.merge({:prevExist => true}))
end

#wait(key, params = {}, &callback) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/etzetera/client.rb', line 44

def wait(key, params = {}, &callback)
  response = request(:get, keys_path(key), :params => params.merge({:wait => true}))

  if block_given?
    yield response
  elsif callback
    sleep 0.5
    callback.call(response)
  else
    parse_response(response)
  end
end