ruby_skynet 1.0.0 → 1.1.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/Gemfile.lock +6 -0
- data/lib/ruby_skynet/doozer/service_registry.rb +240 -0
- data/lib/ruby_skynet/ruby_skynet.rb +12 -17
- data/lib/ruby_skynet/service_registry.rb +21 -236
- data/lib/ruby_skynet/version.rb +1 -1
- data/lib/ruby_skynet/zookeeper/json/serializer.rb +1 -1
- data/lib/ruby_skynet/zookeeper/registry.rb +12 -6
- data/lib/ruby_skynet/zookeeper/service_registry.rb +271 -0
- data/lib/ruby_skynet/zookeeper.rb +1 -0
- metadata +4 -3
- data/lib/ruby_skynet/registry.rb +0 -17
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 088702cd6c216e6b48ec0124fb0ea95438be5a17
|
|
4
|
+
data.tar.gz: 6500952161438b2dcd00f2862164260ddc1788ca
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 44c050a725b5fdf2ebda68a12be4a08117bb067f9df0bd19d4a28223e3f62bbdce5d5fe0dc715088a6857f462682dee61afc7b1e9c8843d52f3a8ee336f4165c
|
|
7
|
+
data.tar.gz: 8cf35886b4c988835b705d39777ac3d74e87ae26fe55b9038d713f6d9f87a06c143a6d5a05ccbfa46b8da0e5c0972148c92c4328406eaf60092b17262dc1353e
|
data/Gemfile.lock
CHANGED
|
@@ -7,8 +7,12 @@ GEM
|
|
|
7
7
|
multi_json (~> 1.3)
|
|
8
8
|
thread_safe (~> 0.1)
|
|
9
9
|
tzinfo (~> 0.3.37)
|
|
10
|
+
atomic (1.1.10)
|
|
10
11
|
atomic (1.1.10-java)
|
|
12
|
+
bson (1.9.0)
|
|
11
13
|
bson (1.9.0-java)
|
|
14
|
+
bson_ext (1.9.0)
|
|
15
|
+
bson (~> 1.9.0)
|
|
12
16
|
gene_pool (1.3.0)
|
|
13
17
|
i18n (0.6.4)
|
|
14
18
|
minitest (4.7.5)
|
|
@@ -39,12 +43,14 @@ GEM
|
|
|
39
43
|
thread_safe (0.1.0)
|
|
40
44
|
atomic
|
|
41
45
|
tzinfo (0.3.37)
|
|
46
|
+
zookeeper (1.4.4)
|
|
42
47
|
zookeeper (1.4.4-java)
|
|
43
48
|
slyphon-log4j (= 1.2.15)
|
|
44
49
|
slyphon-zookeeper_jar (= 3.3.5)
|
|
45
50
|
|
|
46
51
|
PLATFORMS
|
|
47
52
|
java
|
|
53
|
+
ruby
|
|
48
54
|
|
|
49
55
|
DEPENDENCIES
|
|
50
56
|
bson
|
|
@@ -0,0 +1,240 @@
|
|
|
1
|
+
require 'semantic_logger'
|
|
2
|
+
require 'thread_safe'
|
|
3
|
+
require 'gene_pool'
|
|
4
|
+
require 'resolv'
|
|
5
|
+
|
|
6
|
+
#
|
|
7
|
+
# RubySkynet Sevices Registry
|
|
8
|
+
#
|
|
9
|
+
# Based on the Skynet Services Registry, obtains and keeps up to date a list of
|
|
10
|
+
# all services and which servers they are available on.
|
|
11
|
+
#
|
|
12
|
+
module RubySkynet
|
|
13
|
+
module Doozer
|
|
14
|
+
class ServiceRegistry
|
|
15
|
+
include SemanticLogger::Loggable
|
|
16
|
+
|
|
17
|
+
# Create a service registry
|
|
18
|
+
# See: RubyDoozer::Registry for the parameters
|
|
19
|
+
def initialize
|
|
20
|
+
# Registry has the following format
|
|
21
|
+
# Key: [String] 'name/version/region'
|
|
22
|
+
# Value: [Array<String>] 'host:port', 'host:port'
|
|
23
|
+
@cache = ThreadSafe::Hash.new
|
|
24
|
+
|
|
25
|
+
# Supply block to load the current keys from the Registry
|
|
26
|
+
@registry = Doozer::Registry.new(:root => '/services') do |key, value|
|
|
27
|
+
service_info_changed(key, value)
|
|
28
|
+
end
|
|
29
|
+
# Register Callbacks
|
|
30
|
+
@registry.on_update {|path, value| service_info_changed(path, value) }
|
|
31
|
+
@registry.on_delete {|path| service_info_changed(path) }
|
|
32
|
+
|
|
33
|
+
# Zookeeper Registry also supports on_create
|
|
34
|
+
@registry.on_create {|path, value| service_info_changed(path, value) } if @registry.respond_to?(:on_create)
|
|
35
|
+
end
|
|
36
|
+
|
|
37
|
+
# Returns the Service Registry as a Hash
|
|
38
|
+
def to_h
|
|
39
|
+
@cache.dup
|
|
40
|
+
end
|
|
41
|
+
|
|
42
|
+
# Register the supplied service at this Skynet Server host and Port
|
|
43
|
+
def register_service(name, version, region, hostname, port)
|
|
44
|
+
@registry["#{name}/#{version}/#{region}/#{hostname}/#{port}"] = {
|
|
45
|
+
"Config" => {
|
|
46
|
+
"UUID" => "#{hostname}:#{port}-#{$$}-#{name}-#{version}",
|
|
47
|
+
"Name" => name,
|
|
48
|
+
"Version" => version.to_s,
|
|
49
|
+
"Region" => region,
|
|
50
|
+
"ServiceAddr" => {
|
|
51
|
+
"IPAddress" => hostname,
|
|
52
|
+
"Port" => port,
|
|
53
|
+
"MaxPort" => port + 999
|
|
54
|
+
},
|
|
55
|
+
},
|
|
56
|
+
"Registered" => true
|
|
57
|
+
}
|
|
58
|
+
end
|
|
59
|
+
|
|
60
|
+
# Deregister the supplied service from the Registry
|
|
61
|
+
def deregister_service(name, version, region, hostname, port)
|
|
62
|
+
@registry.delete("#{name}/#{version}/#{region}/#{hostname}/#{port}")
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
# Return a server that implements the specified service
|
|
66
|
+
def server_for(name, version='*', region=RubySkynet.region)
|
|
67
|
+
if servers = servers_for(name, version, region)
|
|
68
|
+
# Randomly select one of the servers offering the service
|
|
69
|
+
servers[rand(servers.size)]
|
|
70
|
+
else
|
|
71
|
+
msg = "No servers available for service: #{name} with version: #{version} in region: #{region}"
|
|
72
|
+
logger.warn msg
|
|
73
|
+
raise ServiceUnavailable.new(msg)
|
|
74
|
+
end
|
|
75
|
+
end
|
|
76
|
+
|
|
77
|
+
# Returns [Array<String>] a list of servers implementing the requested service
|
|
78
|
+
def servers_for(name, version='*', region=RubySkynet.region)
|
|
79
|
+
if version == '*'
|
|
80
|
+
# Find the highest version for the named service in this region
|
|
81
|
+
version = -1
|
|
82
|
+
@cache.keys.each do |key|
|
|
83
|
+
if match = key.match(/#{name}\/(\d+)\/#{region}/)
|
|
84
|
+
ver = match[1].to_i
|
|
85
|
+
version = ver if ver > version
|
|
86
|
+
end
|
|
87
|
+
end
|
|
88
|
+
end
|
|
89
|
+
if server_infos = @cache["#{name}/#{version}/#{region}"]
|
|
90
|
+
server_infos.first.servers
|
|
91
|
+
end
|
|
92
|
+
end
|
|
93
|
+
|
|
94
|
+
# Invokes registered callbacks when a specific server is shutdown or terminates
|
|
95
|
+
# Not when a server de-registers itself
|
|
96
|
+
# The callback will only be called once and will need to be re-registered
|
|
97
|
+
# after being called if future callbacks are required for that server
|
|
98
|
+
def on_server_removed(server, &block)
|
|
99
|
+
((@on_server_removed_callbacks ||= ThreadSafe::Hash.new)[server] ||= ThreadSafe::Array.new) << block
|
|
100
|
+
end
|
|
101
|
+
|
|
102
|
+
############################
|
|
103
|
+
protected
|
|
104
|
+
|
|
105
|
+
# Service information changed in doozer, so update internal registry
|
|
106
|
+
def service_info_changed(path, value=nil)
|
|
107
|
+
logger.info("service_info_changed: #{path}", value)
|
|
108
|
+
# path: "TutorialService/1/Development/127.0.0.1/9000"
|
|
109
|
+
e = path.split('/')
|
|
110
|
+
|
|
111
|
+
# Key: [String] 'name/version/region'
|
|
112
|
+
key = "#{e[0]}/#{e[1]}/#{e[2]}"
|
|
113
|
+
hostname, port = e[3], e[4]
|
|
114
|
+
|
|
115
|
+
if value
|
|
116
|
+
if value['Registered']
|
|
117
|
+
add_server(key, hostname, port)
|
|
118
|
+
else
|
|
119
|
+
# Service just de-registered
|
|
120
|
+
remove_server(key, hostname, port, false)
|
|
121
|
+
end
|
|
122
|
+
else
|
|
123
|
+
# Service has stopped and needs to be removed
|
|
124
|
+
remove_server(key, hostname, port, true)
|
|
125
|
+
end
|
|
126
|
+
end
|
|
127
|
+
|
|
128
|
+
# :score: [Integer] Score
|
|
129
|
+
# :servers: [Array<String>] 'host:port', 'host:port'
|
|
130
|
+
ServerInfo = Struct.new(:score, :servers )
|
|
131
|
+
|
|
132
|
+
# Format of the internal services registry
|
|
133
|
+
# key: [String] "<name>/<version>/<region>"
|
|
134
|
+
# value: [ServiceInfo, ServiceInfo]
|
|
135
|
+
# Sorted by highest score first
|
|
136
|
+
|
|
137
|
+
# Add the host to the registry based on it's score
|
|
138
|
+
def add_server(key, hostname, port)
|
|
139
|
+
server = "#{hostname}:#{port}"
|
|
140
|
+
|
|
141
|
+
server_infos = (@cache[key] ||= ThreadSafe::Array.new)
|
|
142
|
+
|
|
143
|
+
# If already present, then nothing to do
|
|
144
|
+
server_info = server_infos.find{|si| si.servers.include?(server)}
|
|
145
|
+
return server_info if server_info
|
|
146
|
+
|
|
147
|
+
# Look for the same score with a different server
|
|
148
|
+
score = self.class.score_for_server(hostname, RubySkynet.local_ip_address)
|
|
149
|
+
logger.info "Service: #{key} now running at #{server} with score #{score}"
|
|
150
|
+
if server_info = server_infos.find{|si| si.score == score}
|
|
151
|
+
server_info.servers << server
|
|
152
|
+
return server_info
|
|
153
|
+
end
|
|
154
|
+
|
|
155
|
+
# New score
|
|
156
|
+
servers = ThreadSafe::Array.new
|
|
157
|
+
servers << server
|
|
158
|
+
server_info = ServerInfo.new(score, servers)
|
|
159
|
+
|
|
160
|
+
# Insert into Array in order of score
|
|
161
|
+
if index = server_infos.find_index {|si| si.score <= score}
|
|
162
|
+
server_infos.insert(index, server_info)
|
|
163
|
+
else
|
|
164
|
+
server_infos << server_info
|
|
165
|
+
end
|
|
166
|
+
server_info
|
|
167
|
+
end
|
|
168
|
+
|
|
169
|
+
# Remove the host from the registry based
|
|
170
|
+
# Returns the server instance if it was removed
|
|
171
|
+
def remove_server(key, hostname, port, notify)
|
|
172
|
+
server = "#{hostname}:#{port}"
|
|
173
|
+
logger.info "Service: #{key} stopped running at #{server}"
|
|
174
|
+
server_info = nil
|
|
175
|
+
if server_infos = @cache[key]
|
|
176
|
+
server_infos.each do |si|
|
|
177
|
+
if si.servers.delete(server)
|
|
178
|
+
server_info = si
|
|
179
|
+
break
|
|
180
|
+
end
|
|
181
|
+
end
|
|
182
|
+
|
|
183
|
+
# Found server
|
|
184
|
+
if server_info
|
|
185
|
+
# Cleanup if no more servers in server list
|
|
186
|
+
server_infos.delete(server_info) if server_info.servers.size == 0
|
|
187
|
+
|
|
188
|
+
# Cleanup if no more server infos
|
|
189
|
+
@cache.delete(key) if server_infos.size == 0
|
|
190
|
+
|
|
191
|
+
server_removed(server) if notify
|
|
192
|
+
end
|
|
193
|
+
end
|
|
194
|
+
server_info
|
|
195
|
+
end
|
|
196
|
+
|
|
197
|
+
# Invoke any registered callbacks for the specific server
|
|
198
|
+
def server_removed(server)
|
|
199
|
+
if @on_server_removed_callbacks && (callbacks = @on_server_removed_callbacks.delete(server))
|
|
200
|
+
callbacks.each do |block|
|
|
201
|
+
begin
|
|
202
|
+
logger.debug "Calling callback for server: #{server}"
|
|
203
|
+
block.call(server)
|
|
204
|
+
rescue Exception => exc
|
|
205
|
+
logger.error("Exception during a callback for server: #{server}", exc)
|
|
206
|
+
end
|
|
207
|
+
end
|
|
208
|
+
end
|
|
209
|
+
end
|
|
210
|
+
|
|
211
|
+
IPV4_REG_EXP = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
|
|
212
|
+
|
|
213
|
+
# Returns [Integer] the score for the supplied ip_address
|
|
214
|
+
# Score currently ranges from 0 to 4 with 4 being the best score
|
|
215
|
+
# If the IP address does not match an IP v4 address a DNS lookup will
|
|
216
|
+
# be performed
|
|
217
|
+
def self.score_for_server(ip_address, local_ip_address)
|
|
218
|
+
ip_address = '127.0.0.1' if ip_address == 'localhost'
|
|
219
|
+
score = 0
|
|
220
|
+
# Each matching element adds 1 to the score
|
|
221
|
+
# 192.168. 0. 0
|
|
222
|
+
# 1
|
|
223
|
+
# 1
|
|
224
|
+
# 1
|
|
225
|
+
# 1
|
|
226
|
+
server_match = IPV4_REG_EXP.match(ip_address) || IPV4_REG_EXP.match(Resolv::DNS.new.getaddress(ip_address).to_s)
|
|
227
|
+
if server_match
|
|
228
|
+
local_match = IPV4_REG_EXP.match(local_ip_address)
|
|
229
|
+
score = 0
|
|
230
|
+
(1..4).each do |i|
|
|
231
|
+
break if local_match[i].to_i != server_match[i].to_i
|
|
232
|
+
score += 1
|
|
233
|
+
end
|
|
234
|
+
end
|
|
235
|
+
score
|
|
236
|
+
end
|
|
237
|
+
|
|
238
|
+
end
|
|
239
|
+
end
|
|
240
|
+
end
|
|
@@ -51,7 +51,15 @@ module RubySkynet
|
|
|
51
51
|
# By default it connects to a local ZooKeeper instance
|
|
52
52
|
# Use .configure! to supply a configuration file with any other settings
|
|
53
53
|
sync_cattr_reader :service_registry do
|
|
54
|
-
ServiceRegistry.new
|
|
54
|
+
ServiceRegistry.new
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
# Returns the current Registry Config information
|
|
58
|
+
#
|
|
59
|
+
# By default it connects to a local ZooKeeper instance
|
|
60
|
+
# Use .configure! to supply a configuration file with any other settings
|
|
61
|
+
def self.registry_config
|
|
62
|
+
@@config.dup if @@config && defined?(@@config)
|
|
55
63
|
end
|
|
56
64
|
|
|
57
65
|
# Set the services registry
|
|
@@ -89,27 +97,14 @@ module RubySkynet
|
|
|
89
97
|
RubySkynet.local_ip_address = config.delete(:local_ip_address) || Common::local_ip_address
|
|
90
98
|
|
|
91
99
|
# Extract just the zookeeper or doozer configuration element
|
|
92
|
-
key = config[:zookeeper] ? :zookeeper : :doozer
|
|
93
100
|
RubySkynet.service_registry = ServiceRegistry.new(
|
|
94
|
-
:
|
|
95
|
-
key => config.delete(key)
|
|
101
|
+
:registry => config[:registry]
|
|
96
102
|
)
|
|
97
103
|
|
|
98
104
|
config.each_pair {|k,v| RubySkynet::Server.logger.warn "Ignoring unknown RubySkynet config option #{k} => #{v}"}
|
|
99
105
|
end
|
|
100
106
|
|
|
101
|
-
#
|
|
102
|
-
|
|
103
|
-
def self.new_cache_registry(root)
|
|
104
|
-
# Load config
|
|
105
|
-
service_registry
|
|
106
|
-
|
|
107
|
-
if zookeeper = @@config[:zookeeper]
|
|
108
|
-
RubySkynet::Zookeeper::CachedRegistry.new(:root => root, :zookeeper => zookeeper)
|
|
109
|
-
else
|
|
110
|
-
raise "How did we get here", @@config
|
|
111
|
-
Doozer::CachedRegistry.new(:root => root, :doozer => @@config[:doozer])
|
|
112
|
-
end
|
|
113
|
-
end
|
|
107
|
+
# Initialize internal class variable
|
|
108
|
+
@@config = nil
|
|
114
109
|
|
|
115
110
|
end
|
|
@@ -1,238 +1,23 @@
|
|
|
1
|
-
|
|
2
|
-
require 'thread_safe'
|
|
3
|
-
require 'gene_pool'
|
|
4
|
-
require 'resolv'
|
|
5
|
-
|
|
6
|
-
#
|
|
7
|
-
# RubySkynet Sevices Registry
|
|
8
|
-
#
|
|
9
|
-
# Based on the Skynet Services Registry, obtains and keeps up to date a list of
|
|
10
|
-
# all services and which servers they are available on.
|
|
11
|
-
#
|
|
1
|
+
# Define RubySkynet::ServiceRegistry based on whether the ZooKeeper or Doozer gem is present
|
|
12
2
|
module RubySkynet
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
#
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
# Zookeeper Registry also supports on_create
|
|
33
|
-
@registry.on_create {|path, value| service_info_changed(path, value) } if @registry.respond_to?(:on_create)
|
|
34
|
-
end
|
|
35
|
-
|
|
36
|
-
# Returns the Service Registry as a Hash
|
|
37
|
-
def to_h
|
|
38
|
-
@cache.dup
|
|
39
|
-
end
|
|
40
|
-
|
|
41
|
-
# Register the supplied service at this Skynet Server host and Port
|
|
42
|
-
def register_service(name, version, region, hostname, port)
|
|
43
|
-
@registry["#{name}/#{version}/#{region}/#{hostname}/#{port}"] = {
|
|
44
|
-
"Config" => {
|
|
45
|
-
"UUID" => "#{hostname}:#{port}-#{$$}-#{name}-#{version}",
|
|
46
|
-
"Name" => name,
|
|
47
|
-
"Version" => version.to_s,
|
|
48
|
-
"Region" => region,
|
|
49
|
-
"ServiceAddr" => {
|
|
50
|
-
"IPAddress" => hostname,
|
|
51
|
-
"Port" => port,
|
|
52
|
-
"MaxPort" => port + 999
|
|
53
|
-
},
|
|
54
|
-
},
|
|
55
|
-
"Registered" => true
|
|
56
|
-
}
|
|
57
|
-
end
|
|
58
|
-
|
|
59
|
-
# Deregister the supplied service from the Registry
|
|
60
|
-
def deregister_service(name, version, region, hostname, port)
|
|
61
|
-
@registry.delete("#{name}/#{version}/#{region}/#{hostname}/#{port}")
|
|
62
|
-
end
|
|
63
|
-
|
|
64
|
-
# Return a server that implements the specified service
|
|
65
|
-
def server_for(name, version='*', region=RubySkynet.region)
|
|
66
|
-
if servers = servers_for(name, version, region)
|
|
67
|
-
# Randomly select one of the servers offering the service
|
|
68
|
-
servers[rand(servers.size)]
|
|
69
|
-
else
|
|
70
|
-
msg = "No servers available for service: #{name} with version: #{version} in region: #{region}"
|
|
71
|
-
logger.warn msg
|
|
72
|
-
raise ServiceUnavailable.new(msg)
|
|
73
|
-
end
|
|
74
|
-
end
|
|
75
|
-
|
|
76
|
-
# Returns [Array<String>] a list of servers implementing the requested service
|
|
77
|
-
def servers_for(name, version='*', region=RubySkynet.region)
|
|
78
|
-
if version == '*'
|
|
79
|
-
# Find the highest version for the named service in this region
|
|
80
|
-
version = -1
|
|
81
|
-
@cache.keys.each do |key|
|
|
82
|
-
if match = key.match(/#{name}\/(\d+)\/#{region}/)
|
|
83
|
-
ver = match[1].to_i
|
|
84
|
-
version = ver if ver > version
|
|
85
|
-
end
|
|
86
|
-
end
|
|
87
|
-
end
|
|
88
|
-
if server_infos = @cache["#{name}/#{version}/#{region}"]
|
|
89
|
-
server_infos.first.servers
|
|
90
|
-
end
|
|
91
|
-
end
|
|
92
|
-
|
|
93
|
-
# Invokes registered callbacks when a specific server is shutdown or terminates
|
|
94
|
-
# Not when a server de-registers itself
|
|
95
|
-
# The callback will only be called once and will need to be re-registered
|
|
96
|
-
# after being called if future callbacks are required for that server
|
|
97
|
-
def on_server_removed(server, &block)
|
|
98
|
-
((@on_server_removed_callbacks ||= ThreadSafe::Hash.new)[server] ||= ThreadSafe::Array.new) << block
|
|
99
|
-
end
|
|
100
|
-
|
|
101
|
-
############################
|
|
102
|
-
protected
|
|
103
|
-
|
|
104
|
-
# Service information changed in doozer, so update internal registry
|
|
105
|
-
def service_info_changed(path, value=nil)
|
|
106
|
-
logger.info("service_info_changed: #{path}", value)
|
|
107
|
-
# path: "TutorialService/1/Development/127.0.0.1/9000"
|
|
108
|
-
e = path.split('/')
|
|
109
|
-
|
|
110
|
-
# Key: [String] 'name/version/region'
|
|
111
|
-
key = "#{e[0]}/#{e[1]}/#{e[2]}"
|
|
112
|
-
hostname, port = e[3], e[4]
|
|
113
|
-
|
|
114
|
-
if value
|
|
115
|
-
if value['Registered']
|
|
116
|
-
add_server(key, hostname, port)
|
|
117
|
-
else
|
|
118
|
-
# Service just de-registered
|
|
119
|
-
remove_server(key, hostname, port, false)
|
|
120
|
-
end
|
|
121
|
-
else
|
|
122
|
-
# Service has stopped and needs to be removed
|
|
123
|
-
remove_server(key, hostname, port, true)
|
|
124
|
-
end
|
|
125
|
-
end
|
|
126
|
-
|
|
127
|
-
# :score: [Integer] Score
|
|
128
|
-
# :servers: [Array<String>] 'host:port', 'host:port'
|
|
129
|
-
ServerInfo = Struct.new(:score, :servers )
|
|
130
|
-
|
|
131
|
-
# Format of the internal services registry
|
|
132
|
-
# key: [String] "<name>/<version>/<region>"
|
|
133
|
-
# value: [ServiceInfo, ServiceInfo]
|
|
134
|
-
# Sorted by highest score first
|
|
135
|
-
|
|
136
|
-
# Add the host to the registry based on it's score
|
|
137
|
-
def add_server(key, hostname, port)
|
|
138
|
-
server = "#{hostname}:#{port}"
|
|
139
|
-
|
|
140
|
-
server_infos = (@cache[key] ||= ThreadSafe::Array.new)
|
|
141
|
-
|
|
142
|
-
# If already present, then nothing to do
|
|
143
|
-
server_info = server_infos.find{|si| si.servers.include?(server)}
|
|
144
|
-
return server_info if server_info
|
|
145
|
-
|
|
146
|
-
# Look for the same score with a different server
|
|
147
|
-
score = self.class.score_for_server(hostname, RubySkynet.local_ip_address)
|
|
148
|
-
logger.info "Service: #{key} now running at #{server} with score #{score}"
|
|
149
|
-
if server_info = server_infos.find{|si| si.score == score}
|
|
150
|
-
server_info.servers << server
|
|
151
|
-
return server_info
|
|
152
|
-
end
|
|
153
|
-
|
|
154
|
-
# New score
|
|
155
|
-
servers = ThreadSafe::Array.new
|
|
156
|
-
servers << server
|
|
157
|
-
server_info = ServerInfo.new(score, servers)
|
|
158
|
-
|
|
159
|
-
# Insert into Array in order of score
|
|
160
|
-
if index = server_infos.find_index {|si| si.score <= score}
|
|
161
|
-
server_infos.insert(index, server_info)
|
|
162
|
-
else
|
|
163
|
-
server_infos << server_info
|
|
164
|
-
end
|
|
165
|
-
server_info
|
|
166
|
-
end
|
|
167
|
-
|
|
168
|
-
# Remove the host from the registry based
|
|
169
|
-
# Returns the server instance if it was removed
|
|
170
|
-
def remove_server(key, hostname, port, notify)
|
|
171
|
-
server = "#{hostname}:#{port}"
|
|
172
|
-
logger.info "Service: #{key} stopped running at #{server}"
|
|
173
|
-
server_info = nil
|
|
174
|
-
if server_infos = @cache[key]
|
|
175
|
-
server_infos.each do |si|
|
|
176
|
-
if si.servers.delete(server)
|
|
177
|
-
server_info = si
|
|
178
|
-
break
|
|
179
|
-
end
|
|
180
|
-
end
|
|
181
|
-
|
|
182
|
-
# Found server
|
|
183
|
-
if server_info
|
|
184
|
-
# Cleanup if no more servers in server list
|
|
185
|
-
server_infos.delete(server_info) if server_info.servers.size == 0
|
|
186
|
-
|
|
187
|
-
# Cleanup if no more server infos
|
|
188
|
-
@cache.delete(key) if server_infos.size == 0
|
|
189
|
-
|
|
190
|
-
server_removed(server) if notify
|
|
191
|
-
end
|
|
192
|
-
end
|
|
193
|
-
server_info
|
|
194
|
-
end
|
|
195
|
-
|
|
196
|
-
# Invoke any registered callbacks for the specific server
|
|
197
|
-
def server_removed(server)
|
|
198
|
-
if @on_server_removed_callbacks && (callbacks = @on_server_removed_callbacks.delete(server))
|
|
199
|
-
callbacks.each do |block|
|
|
200
|
-
begin
|
|
201
|
-
logger.debug "Calling callback for server: #{server}"
|
|
202
|
-
block.call(server)
|
|
203
|
-
rescue Exception => exc
|
|
204
|
-
logger.error("Exception during a callback for server: #{server}", exc)
|
|
205
|
-
end
|
|
206
|
-
end
|
|
207
|
-
end
|
|
208
|
-
end
|
|
209
|
-
|
|
210
|
-
IPV4_REG_EXP = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
|
|
211
|
-
|
|
212
|
-
# Returns [Integer] the score for the supplied ip_address
|
|
213
|
-
# Score currently ranges from 0 to 4 with 4 being the best score
|
|
214
|
-
# If the IP address does not match an IP v4 address a DNS lookup will
|
|
215
|
-
# be performed
|
|
216
|
-
def self.score_for_server(ip_address, local_ip_address)
|
|
217
|
-
ip_address = '127.0.0.1' if ip_address == 'localhost'
|
|
218
|
-
score = 0
|
|
219
|
-
# Each matching element adds 1 to the score
|
|
220
|
-
# 192.168. 0. 0
|
|
221
|
-
# 1
|
|
222
|
-
# 1
|
|
223
|
-
# 1
|
|
224
|
-
# 1
|
|
225
|
-
server_match = IPV4_REG_EXP.match(ip_address) || IPV4_REG_EXP.match(Resolv::DNS.new.getaddress(ip_address).to_s)
|
|
226
|
-
if server_match
|
|
227
|
-
local_match = IPV4_REG_EXP.match(local_ip_address)
|
|
228
|
-
score = 0
|
|
229
|
-
(1..4).each do |i|
|
|
230
|
-
break if local_match[i].to_i != server_match[i].to_i
|
|
231
|
-
score += 1
|
|
232
|
-
end
|
|
233
|
-
end
|
|
234
|
-
score
|
|
235
|
-
end
|
|
236
|
-
|
|
3
|
+
begin
|
|
4
|
+
require 'zookeeper'
|
|
5
|
+
require 'zookeeper/client'
|
|
6
|
+
require 'ruby_skynet/zookeeper/service_registry'
|
|
7
|
+
# Monkey-patch so that the Zookeeper JRuby code can handle nil values in Zookeeper
|
|
8
|
+
require 'ruby_skynet/zookeeper/extensions/java_base' if defined?(::JRUBY_VERSION)
|
|
9
|
+
ServiceRegistry = RubySkynet::Zookeeper::ServiceRegistry
|
|
10
|
+
CachedRegistry = RubySkynet::Zookeeper::CachedRegistry
|
|
11
|
+
Registry = RubySkynet::Zookeeper::Registry
|
|
12
|
+
rescue LoadError
|
|
13
|
+
begin
|
|
14
|
+
require 'ruby_doozer'
|
|
15
|
+
require 'ruby_skynet/doozer/service_registry'
|
|
16
|
+
rescue LoadError
|
|
17
|
+
raise LoadError, "Must gem install either 'zookeeper' or 'ruby_doozer'. 'zookeeper' is recommended"
|
|
18
|
+
end
|
|
19
|
+
ServiceRegistry = RubySkynet::Doozer::ServiceRegistry
|
|
20
|
+
CachedRegistry = Doozer::CachedRegistry
|
|
21
|
+
Registry = Doozer::Registry
|
|
237
22
|
end
|
|
238
|
-
end
|
|
23
|
+
end
|
data/lib/ruby_skynet/version.rb
CHANGED
|
@@ -34,7 +34,10 @@ module RubySkynet
|
|
|
34
34
|
# significant traffic since it will also monitor ZooKeeper Admin changes
|
|
35
35
|
# Mandatory
|
|
36
36
|
#
|
|
37
|
-
# :
|
|
37
|
+
# :ephemeral [Boolean]
|
|
38
|
+
# All set operations of non-nil values will result in ephemeral nodes.
|
|
39
|
+
#
|
|
40
|
+
# :registry [Hash|ZooKeeper]
|
|
38
41
|
# ZooKeeper configuration information, or an existing
|
|
39
42
|
# ZooKeeper ( ZooKeeper client) instance
|
|
40
43
|
#
|
|
@@ -87,6 +90,9 @@ module RubySkynet
|
|
|
87
90
|
@serializer = params.delete(:serializer) || RubySkynet::Zookeeper::Json::Serializer
|
|
88
91
|
@deserializer = params.delete(:deserializer) || RubySkynet::Zookeeper::Json::Deserializer
|
|
89
92
|
|
|
93
|
+
@ephemeral = params.delete(:ephemeral)
|
|
94
|
+
@ephemeral = false if @ephemeral.nil?
|
|
95
|
+
|
|
90
96
|
# Generate warning log entries for any unknown configuration options
|
|
91
97
|
params.each_pair {|k,v| logger.warn "Ignoring unknown configuration option: #{k}"}
|
|
92
98
|
|
|
@@ -206,7 +212,7 @@ module RubySkynet
|
|
|
206
212
|
# Default: '*'
|
|
207
213
|
#
|
|
208
214
|
# value
|
|
209
|
-
# New value from
|
|
215
|
+
# New value from the registry
|
|
210
216
|
#
|
|
211
217
|
# version
|
|
212
218
|
# The version number of this node
|
|
@@ -230,12 +236,12 @@ module RubySkynet
|
|
|
230
236
|
#
|
|
231
237
|
# Parameters passed to the block:
|
|
232
238
|
# key
|
|
233
|
-
# The key that was updated in
|
|
239
|
+
# The key that was updated in the registry
|
|
234
240
|
# Supplying a key of '*' means all paths
|
|
235
241
|
# Default: '*'
|
|
236
242
|
#
|
|
237
243
|
# value
|
|
238
|
-
# New value from
|
|
244
|
+
# New value from the registry
|
|
239
245
|
#
|
|
240
246
|
# version
|
|
241
247
|
# The version number of this node
|
|
@@ -259,7 +265,7 @@ module RubySkynet
|
|
|
259
265
|
#
|
|
260
266
|
# Parameters passed to the block:
|
|
261
267
|
# key
|
|
262
|
-
# The key that was deleted from
|
|
268
|
+
# The key that was deleted from the registry
|
|
263
269
|
# Supplying a key of '*' means all paths
|
|
264
270
|
# Default: '*'
|
|
265
271
|
#
|
|
@@ -314,7 +320,7 @@ module RubySkynet
|
|
|
314
320
|
@zookeeper.create(:path => path)
|
|
315
321
|
end
|
|
316
322
|
if value
|
|
317
|
-
@zookeeper.create(:path => full_path, :data => value)
|
|
323
|
+
@zookeeper.create(:path => full_path, :data => value, :ephemeral => @ephemeral)
|
|
318
324
|
else
|
|
319
325
|
@zookeeper.create(:path => full_path)
|
|
320
326
|
end
|
|
@@ -0,0 +1,271 @@
|
|
|
1
|
+
require 'semantic_logger'
|
|
2
|
+
require 'thread_safe'
|
|
3
|
+
require 'gene_pool'
|
|
4
|
+
require 'resolv'
|
|
5
|
+
|
|
6
|
+
#
|
|
7
|
+
# RubySkynet Sevices Registry
|
|
8
|
+
#
|
|
9
|
+
# Based on the Skynet Services Registry, obtains and keeps up to date a list of
|
|
10
|
+
# all services and which servers they are available on.
|
|
11
|
+
#
|
|
12
|
+
module RubySkynet
|
|
13
|
+
module Zookeeper
|
|
14
|
+
class ServiceRegistry
|
|
15
|
+
include SemanticLogger::Loggable
|
|
16
|
+
|
|
17
|
+
# Create a service registry
|
|
18
|
+
# See: RubyDoozer::Registry for the parameters
|
|
19
|
+
def initialize(params = {})
|
|
20
|
+
# Registry has the following format
|
|
21
|
+
# Key: [String] 'name/version/region'
|
|
22
|
+
# Value: [Array<String>] 'host:port', 'host:port'
|
|
23
|
+
@cache = ThreadSafe::Hash.new
|
|
24
|
+
@notifications_cache = ThreadSafe::Hash.new
|
|
25
|
+
|
|
26
|
+
# Supply block to load the current keys from the Registry
|
|
27
|
+
params[:root] = '/instances'
|
|
28
|
+
params[:ephemeral] = true
|
|
29
|
+
@registry = Zookeeper::Registry.new(params) do |key, value|
|
|
30
|
+
service_info_created(key, value)
|
|
31
|
+
end
|
|
32
|
+
# Register Callbacks
|
|
33
|
+
@registry.on_create {|path, value| service_info_created(path, value) }
|
|
34
|
+
@registry.on_update {|path, value| service_info_updated(path, value) }
|
|
35
|
+
@registry.on_delete {|path| service_info_deleted(path) }
|
|
36
|
+
end
|
|
37
|
+
|
|
38
|
+
# Returns the Service Registry as a Hash
|
|
39
|
+
def to_h
|
|
40
|
+
@cache.dup
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
# Register the supplied service at this Skynet Server host and Port
|
|
44
|
+
# Returns the UUID for the service that was created
|
|
45
|
+
def register_service(name, version, region, hostname, port)
|
|
46
|
+
uuid = "#{hostname}:#{port}-#{$$}-#{name}-#{version}"
|
|
47
|
+
# TODO Make sets ephemeral
|
|
48
|
+
@registry[File.join(uuid,'addr')] = "#{hostname}:#{port}"
|
|
49
|
+
@registry[File.join(uuid,'name')] = name
|
|
50
|
+
@registry[File.join(uuid,'version')] = version
|
|
51
|
+
@registry[File.join(uuid,'region')] = region
|
|
52
|
+
@registry[File.join(uuid,'registered')] = true
|
|
53
|
+
uuid
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
# Deregister the supplied service from the Registry
|
|
57
|
+
def deregister_service(name, version, region, hostname, port)
|
|
58
|
+
uuid = "#{hostname}:#{port}-#{$$}-#{name}-#{version}"
|
|
59
|
+
@registry.delete(File.join(uuid,'addr'), false)
|
|
60
|
+
@registry.delete(File.join(uuid,'name'), false)
|
|
61
|
+
@registry.delete(File.join(uuid,'version'), false)
|
|
62
|
+
@registry.delete(File.join(uuid,'region'), false)
|
|
63
|
+
@registry.delete(File.join(uuid,'registered'), false)
|
|
64
|
+
@registry.delete(uuid, false)
|
|
65
|
+
end
|
|
66
|
+
|
|
67
|
+
# Return a server that implements the specified service
|
|
68
|
+
def server_for(name, version='*', region=RubySkynet.region)
|
|
69
|
+
if servers = servers_for(name, version, region)
|
|
70
|
+
# Randomly select one of the servers offering the service
|
|
71
|
+
servers[rand(servers.size)]
|
|
72
|
+
else
|
|
73
|
+
msg = "No servers available for service: #{name} with version: #{version} in region: #{region}"
|
|
74
|
+
logger.warn msg
|
|
75
|
+
raise ServiceUnavailable.new(msg)
|
|
76
|
+
end
|
|
77
|
+
end
|
|
78
|
+
|
|
79
|
+
# Returns [Array<String>] a list of servers implementing the requested service
|
|
80
|
+
def servers_for(name, version='*', region=RubySkynet.region)
|
|
81
|
+
if version == '*'
|
|
82
|
+
# Find the highest version for the named service in this region
|
|
83
|
+
version = -1
|
|
84
|
+
@cache.keys.each do |key|
|
|
85
|
+
if match = key.match(/#{name}\/(\d+)\/#{region}/)
|
|
86
|
+
ver = match[1].to_i
|
|
87
|
+
version = ver if ver > version
|
|
88
|
+
end
|
|
89
|
+
end
|
|
90
|
+
end
|
|
91
|
+
if server_infos = @cache["#{name}/#{version}/#{region}"]
|
|
92
|
+
server_infos.first.servers
|
|
93
|
+
end
|
|
94
|
+
end
|
|
95
|
+
|
|
96
|
+
# Invokes registered callbacks when a specific server is shutdown or terminates
|
|
97
|
+
# Not when a server de-registers itself
|
|
98
|
+
# The callback will only be called once and will need to be re-registered
|
|
99
|
+
# after being called if future callbacks are required for that server
|
|
100
|
+
def on_server_removed(server, &block)
|
|
101
|
+
((@on_server_removed_callbacks ||= ThreadSafe::Hash.new)[server] ||= ThreadSafe::Array.new) << block
|
|
102
|
+
end
|
|
103
|
+
|
|
104
|
+
############################
|
|
105
|
+
protected
|
|
106
|
+
|
|
107
|
+
def service_info_deleted(path)
|
|
108
|
+
logger.info("service_info_deleted: #{path}")
|
|
109
|
+
# path: "uuid/key"
|
|
110
|
+
uuid, key = path.split('/')
|
|
111
|
+
if (key == 'registered')
|
|
112
|
+
if server = @notifications_cache.delete(uuid)
|
|
113
|
+
hostname, port = server['addr'].split(':')
|
|
114
|
+
# Service has stopped and needs to be removed
|
|
115
|
+
remove_server(File.join(server['name'], server['version'].to_s, server['region']), hostname, port, true)
|
|
116
|
+
end
|
|
117
|
+
end
|
|
118
|
+
end
|
|
119
|
+
|
|
120
|
+
# Service information changed, so update internal registry
|
|
121
|
+
def service_info_created(path, value=nil)
|
|
122
|
+
logger.info("service_info_created: #{path}", value)
|
|
123
|
+
# path: "uuid/key"
|
|
124
|
+
uuid, key = path.split('/')
|
|
125
|
+
|
|
126
|
+
# Big Assumption: 'registered' event will be received last as true
|
|
127
|
+
if (key == 'registered') && (value == true)
|
|
128
|
+
server = @notifications_cache[uuid]
|
|
129
|
+
if server && server['addr'] && server['name'] && server['version'] && server['region']
|
|
130
|
+
hostname, port = server['addr'].split(':')
|
|
131
|
+
add_server(File.join(server['name'], server['version'].to_s, server['region']), hostname, port)
|
|
132
|
+
else
|
|
133
|
+
logger.warn "Registered notification received for #{uuid} but is missing critical information. Received:", server
|
|
134
|
+
end
|
|
135
|
+
else
|
|
136
|
+
(@notifications_cache[uuid] ||= ThreadSafe::Hash.new)[key] = value
|
|
137
|
+
end
|
|
138
|
+
end
|
|
139
|
+
|
|
140
|
+
def service_info_updated(path, value=nil)
|
|
141
|
+
logger.info("service_info_updated: #{path}", value)
|
|
142
|
+
# path: "uuid/key"
|
|
143
|
+
uuid, key = path.split('/')
|
|
144
|
+
|
|
145
|
+
# Big Assumption: 'registered' event will be received last as true
|
|
146
|
+
if (key == 'registered') && (value == true)
|
|
147
|
+
server = @notifications_cache[uuid]
|
|
148
|
+
if server && server['addr'] && server['name'] && server['version'] && server['region']
|
|
149
|
+
hostname, port = server['addr'].split(':')
|
|
150
|
+
add_server(File.join(server['name'], server['version'].to_s, server['region']), hostname, port)
|
|
151
|
+
else
|
|
152
|
+
logger.warn "Registered notification received for #{uuid} but is missing critical information. Received:", server
|
|
153
|
+
end
|
|
154
|
+
else
|
|
155
|
+
(@notifications_cache[uuid] ||= ThreadSafe::Hash.new)[key] = value
|
|
156
|
+
end
|
|
157
|
+
end
|
|
158
|
+
|
|
159
|
+
# :score: [Integer] Score
|
|
160
|
+
# :servers: [Array<String>] 'host:port', 'host:port'
|
|
161
|
+
ServerInfo = Struct.new(:score, :servers )
|
|
162
|
+
|
|
163
|
+
# Format of the internal services registry
|
|
164
|
+
# key: [String] "<name>/<version>/<region>"
|
|
165
|
+
# value: [ServiceInfo, ServiceInfo]
|
|
166
|
+
# Sorted by highest score first
|
|
167
|
+
|
|
168
|
+
# Add the host to the registry based on it's score
|
|
169
|
+
def add_server(key, hostname, port)
|
|
170
|
+
server = "#{hostname}:#{port}"
|
|
171
|
+
|
|
172
|
+
server_infos = (@cache[key] ||= ThreadSafe::Array.new)
|
|
173
|
+
|
|
174
|
+
# If already present, then nothing to do
|
|
175
|
+
server_info = server_infos.find{|si| si.servers.include?(server)}
|
|
176
|
+
return server_info if server_info
|
|
177
|
+
|
|
178
|
+
# Look for the same score with a different server
|
|
179
|
+
score = self.class.score_for_server(hostname, RubySkynet.local_ip_address)
|
|
180
|
+
logger.info "Service: #{key} now running at #{server} with score #{score}"
|
|
181
|
+
if server_info = server_infos.find{|si| si.score == score}
|
|
182
|
+
server_info.servers << server
|
|
183
|
+
return server_info
|
|
184
|
+
end
|
|
185
|
+
|
|
186
|
+
# New score
|
|
187
|
+
servers = ThreadSafe::Array.new
|
|
188
|
+
servers << server
|
|
189
|
+
server_info = ServerInfo.new(score, servers)
|
|
190
|
+
|
|
191
|
+
# Insert into Array in order of score
|
|
192
|
+
if index = server_infos.find_index {|si| si.score <= score}
|
|
193
|
+
server_infos.insert(index, server_info)
|
|
194
|
+
else
|
|
195
|
+
server_infos << server_info
|
|
196
|
+
end
|
|
197
|
+
server_info
|
|
198
|
+
end
|
|
199
|
+
|
|
200
|
+
# Remove the host from the registry based
|
|
201
|
+
# Returns the server instance if it was removed
|
|
202
|
+
def remove_server(key, hostname, port, notify)
|
|
203
|
+
server = "#{hostname}:#{port}"
|
|
204
|
+
logger.info "Service: #{key} stopped running at #{server}"
|
|
205
|
+
server_info = nil
|
|
206
|
+
if server_infos = @cache[key]
|
|
207
|
+
server_infos.each do |si|
|
|
208
|
+
if si.servers.delete(server)
|
|
209
|
+
server_info = si
|
|
210
|
+
break
|
|
211
|
+
end
|
|
212
|
+
end
|
|
213
|
+
|
|
214
|
+
# Found server
|
|
215
|
+
if server_info
|
|
216
|
+
# Cleanup if no more servers in server list
|
|
217
|
+
server_infos.delete(server_info) if server_info.servers.size == 0
|
|
218
|
+
|
|
219
|
+
# Cleanup if no more server infos
|
|
220
|
+
@cache.delete(key) if server_infos.size == 0
|
|
221
|
+
|
|
222
|
+
server_removed(server) if notify
|
|
223
|
+
end
|
|
224
|
+
end
|
|
225
|
+
server_info
|
|
226
|
+
end
|
|
227
|
+
|
|
228
|
+
# Invoke any registered callbacks for the specific server
|
|
229
|
+
def server_removed(server)
|
|
230
|
+
if @on_server_removed_callbacks && (callbacks = @on_server_removed_callbacks.delete(server))
|
|
231
|
+
callbacks.each do |block|
|
|
232
|
+
begin
|
|
233
|
+
logger.debug "Calling callback for server: #{server}"
|
|
234
|
+
block.call(server)
|
|
235
|
+
rescue Exception => exc
|
|
236
|
+
logger.error("Exception during a callback for server: #{server}", exc)
|
|
237
|
+
end
|
|
238
|
+
end
|
|
239
|
+
end
|
|
240
|
+
end
|
|
241
|
+
|
|
242
|
+
IPV4_REG_EXP = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
|
|
243
|
+
|
|
244
|
+
# Returns [Integer] the score for the supplied ip_address
|
|
245
|
+
# Score currently ranges from 0 to 4 with 4 being the best score
|
|
246
|
+
# If the IP address does not match an IP v4 address a DNS lookup will
|
|
247
|
+
# be performed
|
|
248
|
+
def self.score_for_server(ip_address, local_ip_address)
|
|
249
|
+
ip_address = '127.0.0.1' if ip_address == 'localhost'
|
|
250
|
+
score = 0
|
|
251
|
+
# Each matching element adds 1 to the score
|
|
252
|
+
# 192.168. 0. 0
|
|
253
|
+
# 1
|
|
254
|
+
# 1
|
|
255
|
+
# 1
|
|
256
|
+
# 1
|
|
257
|
+
server_match = IPV4_REG_EXP.match(ip_address) || IPV4_REG_EXP.match(Resolv::DNS.new.getaddress(ip_address).to_s)
|
|
258
|
+
if server_match
|
|
259
|
+
local_match = IPV4_REG_EXP.match(local_ip_address)
|
|
260
|
+
score = 0
|
|
261
|
+
(1..4).each do |i|
|
|
262
|
+
break if local_match[i].to_i != server_match[i].to_i
|
|
263
|
+
score += 1
|
|
264
|
+
end
|
|
265
|
+
end
|
|
266
|
+
score
|
|
267
|
+
end
|
|
268
|
+
|
|
269
|
+
end
|
|
270
|
+
end
|
|
271
|
+
end
|
|
@@ -2,6 +2,7 @@ require 'semantic_logger'
|
|
|
2
2
|
module RubySkynet
|
|
3
3
|
module Zookeeper
|
|
4
4
|
autoload :Registry, 'ruby_skynet/zookeeper/registry'
|
|
5
|
+
autoload :ServiceRegistry, 'ruby_skynet/zookeeper/service_registry'
|
|
5
6
|
autoload :CachedRegistry, 'ruby_skynet/zookeeper/cached_registry'
|
|
6
7
|
module Json
|
|
7
8
|
autoload :Deserializer, 'ruby_skynet/zookeeper/json/deserializer'
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: ruby_skynet
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 1.
|
|
4
|
+
version: 1.1.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Reid Morrison
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2013-
|
|
11
|
+
date: 2013-07-08 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: semantic_logger
|
|
@@ -115,10 +115,10 @@ files:
|
|
|
115
115
|
- lib/ruby_skynet/client.rb
|
|
116
116
|
- lib/ruby_skynet/common.rb
|
|
117
117
|
- lib/ruby_skynet/connection.rb
|
|
118
|
+
- lib/ruby_skynet/doozer/service_registry.rb
|
|
118
119
|
- lib/ruby_skynet/exceptions.rb
|
|
119
120
|
- lib/ruby_skynet/railtie.rb
|
|
120
121
|
- lib/ruby_skynet/railties/ruby_skynet.rake
|
|
121
|
-
- lib/ruby_skynet/registry.rb
|
|
122
122
|
- lib/ruby_skynet/ruby_skynet.rb
|
|
123
123
|
- lib/ruby_skynet/server.rb
|
|
124
124
|
- lib/ruby_skynet/service.rb
|
|
@@ -130,6 +130,7 @@ files:
|
|
|
130
130
|
- lib/ruby_skynet/zookeeper/json/deserializer.rb
|
|
131
131
|
- lib/ruby_skynet/zookeeper/json/serializer.rb
|
|
132
132
|
- lib/ruby_skynet/zookeeper/registry.rb
|
|
133
|
+
- lib/ruby_skynet/zookeeper/service_registry.rb
|
|
133
134
|
- test/client_test.rb
|
|
134
135
|
- test/service_registry_test.rb
|
|
135
136
|
- test/service_test.rb
|
data/lib/ruby_skynet/registry.rb
DELETED
|
@@ -1,17 +0,0 @@
|
|
|
1
|
-
# Define RubySkynet::Registry based on whether the ZooKeeper or Doozer gem is present
|
|
2
|
-
module RubySkynet
|
|
3
|
-
begin
|
|
4
|
-
require 'zookeeper'
|
|
5
|
-
require 'zookeeper/client'
|
|
6
|
-
# Monkey-patch so that the Zookeeper JRuby code can handle nil values in Zookeeper
|
|
7
|
-
require 'ruby_skynet/zookeeper/extensions/java_base' if defined?(::JRUBY_VERSION)
|
|
8
|
-
Registry = RubySkynet::Zookeeper::Registry
|
|
9
|
-
rescue LoadError
|
|
10
|
-
begin
|
|
11
|
-
require 'ruby_doozer'
|
|
12
|
-
rescue LoadError
|
|
13
|
-
raise LoadError, "Must gem install either 'zookeeper' or 'ruby_doozer'. 'zookeeper' is recommended"
|
|
14
|
-
end
|
|
15
|
-
Registry = Doozer::Registry
|
|
16
|
-
end
|
|
17
|
-
end
|