1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
require 'net/https'
require 'date'
require 'time'
require 'uri'
require 'benchmark'
module ActiveResource
class ConnectionError < StandardError
attr_reader :response
def initialize(response, message = nil)
@response = response
@message = message
end
def to_s
"Failed with #{response.code}"
end
end
class ClientError < ConnectionError; end # 4xx Client Error
class ResourceNotFound < ClientError; end # 404 Not Found
class ResourceConflict < ClientError; end # 409 Conflict
class ServerError < ConnectionError; end # 5xx Server Error
# 405 Method Not Allowed
class MethodNotAllowed < ClientError
def allowed_methods
@response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
end
end
# Class to handle connections to remote services.
class Connection
attr_reader :site
class << self
def requests
@@requests ||= []
end
def default_header
class << self ; attr_reader :default_header end
@default_header = { 'Content-Type' => 'application/xml' }
end
end
def initialize(site)
raise ArgumentError, 'Missing site URI' unless site
self.site = site
end
# Set URI for remote service.
def site=(site)
@site = site.is_a?(URI) ? site : URI.parse(site)
end
# Execute a GET request.
# Used to get (find) resources.
def get(path, headers = {})
xml_from_response(request(:get, path, build_request_headers(headers)))
end
# Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
# Used to delete resources.
def delete(path, headers = {})
request(:delete, path, build_request_headers(headers))
end
# Execute a PUT request (see HTTP protocol documentation if unfamiliar).
# Used to update resources.
def put(path, body = '', headers = {})
request(:put, path, body, build_request_headers(headers))
end
# Execute a POST request.
# Used to create new resources.
def post(path, body = '', headers = {})
request(:post, path, body, build_request_headers(headers))
end
def xml_from_response(response)
if response = from_xml_data(Hash.from_xml(response.body))
response.first
else
nil
end
end
private
# Makes request to remote service.
def request(method, path, *arguments)
logger.info "#{method.to_s.upcase} #{site.scheme}://#{site.host}:#{site.port}#{path}" if logger
result = nil
time = Benchmark.realtime { result = http.send(method, path, *arguments) }
logger.info "--> #{result.code} #{result.message} (#{result.body.length}b %.2fs)" % time if logger
handle_response(result)
end
# Handles response and error codes from remote service.
def handle_response(response)
case response.code.to_i
when 200...400
response
when 404
raise(ResourceNotFound.new(response))
when 405
raise(MethodNotAllowed.new(response))
when 409
raise(ResourceConflict.new(response))
when 422
raise(ResourceInvalid.new(response))
when 401...500
raise(ClientError.new(response))
when 500...600
raise(ServerError.new(response))
else
raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
end
end
# Creates new (or uses currently instantiated) Net::HTTP instance for communication with
# remote service and resources.
def http
unless @http
@http = Net::HTTP.new(@site.host, @site.port)
@http.use_ssl = @site.is_a?(URI::HTTPS)
@http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @http.use_ssl
end
@http
end
# Builds headers for request to remote service.
def build_request_headers(headers)
authorization_header.update(self.class.default_header).update(headers)
end
# Sets authorization header; authentication information is pulled from credentials provided with site URI.
def authorization_header
(@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
end
def logger #:nodoc:
ActiveResource::Base.logger
end
# Manipulate from_xml Hash, because xml_simple is not exactly what we
# want for ActiveResource.
def from_xml_data(data)
case data
when Hash
if data.keys.size == 1
case data.values.first
when Hash then [ from_xml_data(data.values.first) ]
when Array then from_xml_data(data.values.first)
else data.values.first
end
else
data.each_key { |key| data[key] = from_xml_data(data[key]) }
data
end
when Array then data.collect { |val| from_xml_data(val) }
else data
end
end
end
end
|