blob: 01bd298bcec48d51de773528d5f8437b0b0ad096 (
plain) (
blame)
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
|
module ActionService # :nodoc:
module Router # :nodoc:
module ActionController # :nodoc:
def self.append_features(base) # :nodoc:
base.add_service_api_callback do |container_class, api|
if container_class.service_dispatching_mode == :direct && !container_class.method_defined?(:api)
container_class.class_eval <<-EOS
def api
process_action_service_request
end
EOS
end
end
base.add_service_definition_callback do |klass, name, info|
if klass.service_dispatching_mode == :delegated
klass.class_eval <<-EOS
def #{name}
process_action_service_request
end
EOS
end
end
base.send(:include, ActionService::Router::ActionController::InstanceMethods)
end
module InstanceMethods # :nodoc:
private
def process_action_service_request
protocol_request = nil
begin
begin
protocol_request = probe_request_protocol(self.request)
rescue Exception => e
logger.error "Invalid request: #{e.message}"
logger.error self.request.raw_post
raise
end
if protocol_request
log_request(protocol_request)
protocol_response = dispatch_service_request(protocol_request)
log_response(protocol_response)
response_options = {
:type => protocol_response.content_type,
:disposition => 'inline'
}
send_data(protocol_response.raw_body, response_options)
else
logger.fatal "Invalid Action Service service or method requested"
render_text 'Internal protocol error', "500 Invalid service/method"
end
rescue Exception => e
log_error e unless logger.nil?
exc_response = nil
case service_dispatching_mode
when :direct
if self.class.service_exception_reporting
exc_response = protocol_request.protocol.marshal_exception(e)
end
when :delegated
service_object = service_object(protocol_request.service_name) rescue nil
if service_object && service_object.class.service_exception_reporting
exc_response = protocol_request.protocol.marshal_exception(e) rescue nil
end
end
if exc_response
response_options = {
:type => exc_response.content_type,
:disposition => 'inline'
}
log_response exc_response
send_data(exc_response.raw_body, response_options)
else
render_text 'Internal protocol error', "500 #{e.message}"
end
end
end
def log_request(protocol_request)
unless logger.nil?
service_name = protocol_request.service_name
method_name = protocol_request.public_method_name
logger.info "\nProcessing Action Service Request: #{service_name}##{method_name}"
logger.info "Raw Request Body:"
logger.info protocol_request.raw_body
end
end
def log_response(protocol_response)
unless logger.nil?
logger.info "\nRaw Response Body:"
logger.info protocol_response.raw_body
end
end
end
end
end
end
|
