Class: Baykit::BayServer::Docker::Ajp::AjpInboundHandler

Inherits:
AjpProtocolHandler
  • Object
show all
Includes:
Agent, Command, Base::InboundHandler, Protocol, Tours, Util
Defined in:
lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb

Defined Under Namespace

Classes: InboundProtocolHandlerFactory

Constant Summary collapse

STATE_READ_FORWARD_REQUEST = 
:FORWARD_REQUEST
STATE_READ_DATA = 
:READ_DATA
DUMMY_KEY = 
1

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from AjpProtocolHandler

#max_req_packet_data_size, #max_res_packet_data_size, #protocol, #to_s

Constructor Details

#initialize(pkt_store) ⇒ AjpInboundHandler

Returns a new instance of AjpInboundHandler.



40
41
42
43
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 40

def initialize(pkt_store)
  super(pkt_store, true)
  reset_state()
end

Instance Attribute Details

#cur_tour_id ⇒ Object (readonly)

Returns the value of attribute cur_tour_id.



34
35
36
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 34

def cur_tour_id
  @cur_tour_id
end

#keeping ⇒ Object (readonly)

Returns the value of attribute keeping.



38
39
40
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 38

def keeping
  @keeping
end

#req_command ⇒ Object (readonly)

Returns the value of attribute req_command.



35
36
37
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 35

def req_command
  @req_command
end

#state ⇒ Object (readonly)

Returns the value of attribute state.



37
38
39
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 37

def state
  @state
end

Instance Method Details

#handle_data(cmd) ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 187

def handle_data(cmd)
  BayLog.debug("%s handleData len=%s", @ship, cmd.length)

  if @state != STATE_READ_DATA
    raise RuntimeError.new("Invalid AJP command: #{cmd.type} state=#{@state}")
  end

  tur = @ship.get_tour(DUMMY_KEY)
  success = tur.req.post_content(Tour::TOUR_ID_NOCHECK, cmd.data, cmd.start, cmd.length)

  if tur.req.bytes_posted == tur.req.bytes_limit
    # request content completed

    if tur.error != nil
      tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, tur.error)
      reset_state()
      return NextSocketAction::WRITE
    else
      begin
        end_req_content(tur)
        return NextSocketAction::CONTINUE
      rescue HttpException => e
        tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
        reset_state()
        return NextSocketAction::WRITE
      end
    end
  else
    bch = CmdGetBodyChunk.new()
    bch.req_len = tur.req.bytes_limit - tur.req.bytes_posted
    if bch.req_len > AjpPacket::MAX_DATA_LEN
      bch.req_len = AjpPacket::MAX_DATA_LEN
    end
    command_packer.post(@ship, bch)

    if !success
      return NextSocketAction::SUSPEND
    else
      return NextSocketAction::CONTINUE
    end
  end
end

#handle_end_response(cmd) ⇒ Object 



244
245
246
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 244

def handle_end_response(cmd)
  raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
end

#handle_forward_request(cmd) ⇒ Object

implements AjpCommandHandler



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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 112

def handle_forward_request(cmd)
  BayLog.debug("%s handleForwardRequest method=%s uri=%s", @ship, cmd.method, cmd.req_uri)
  if @state != STATE_READ_FORWARD_REQUEST
    raise ProtocolException.new("Invalid AJP command: #{cmd.type}")
  end

  @keeping = false
  @req_command = cmd
  tur = @ship.get_tour(DUMMY_KEY)
  if tur == nil
    BayLog.error(BayMessage.get(:INT_NO_MORE_TOURS))
    tur = @ship.get_tour(AjpInboundHandler::DUMMY_KEY, true)
    tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::SERVICE_UNAVAILABLE, "No available tours")
    tur.res.end_content(Tour::TOUR_ID_NOCHECK)
    @ship.agent.shutdown(false)
    return NextSocketAction::CONTINUE
  end

  @cur_tour_id = tur.id
  tur.req.uri = cmd.req_uri
  tur.req.protocol = cmd.protocol
  tur.req.method = cmd.method
  cmd.headers.copy_to(tur.req.headers)
  query_string = cmd.attributes["?query_string"]

  if StringUtil.set?(query_string)
    tur.req.uri += "?" + query_string
  end

  BayLog.debug("%s read header method=%s protocol=%s uri=%s contlen=%d",
               tur, tur.req.method, tur.req.protocol, tur.req.uri, tur.req.headers.content_length)

  if BayServer.harbor.trace_header?
    cmd.headers.names.each do |name|
      cmd.headers.values(name).each do |value|
        BayLog.info("%s header: %s=%s", tur, name, value)
      end
    end
  end

  req_cont_len = cmd.headers.content_length
  if req_cont_len > 0
    sid = @ship.ship_id
    tur.req.set_consume_listener(req_cont_len) do |len, resume|
      if resume
        @ship.resume(sid)
      end
    end
  end

  begin
    start_tour(tur)

    if req_cont_len <= 0
      end_req_content(tur)
    else
      change_state(STATE_READ_DATA)
    end

    return NextSocketAction::CONTINUE
  rescue HttpException => e
    if req_cont_len <= 0
      tur.res.send_http_exception(Tour::TOUR_ID_NOCHECK, e)
      reset_state()
      return NextSocketAction::WRITE
    else
      # Delay send
      change_state(STATE_READ_DATA)
      tur.error = e
      tur.req.set_content_handler(ReqContentHandler::DEV_NULL)
      return NextSocketAction::CONTINUE
    end
  end
end

#handle_get_body_chunk(cmd) ⇒ Object 



248
249
250
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 248

def handle_get_body_chunk(cmd)
  raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
end

#handle_send_body_chunk(cmd) ⇒ Object 



230
231
232
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 230

def handle_send_body_chunk(cmd)
  raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
end

#handle_send_headers(cmd) ⇒ Object 



234
235
236
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 234

def handle_send_headers(cmd)
  raise RuntimeError.new "Invalid AJP command: #{cmd.type}"
end

#handle_shutdown(cmd) ⇒ Object 



238
239
240
241
242
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 238

def handle_shutdown(cmd)
  BayLog.info("%s handle_shutdown", @ship)
  BayServer.shutdown
  NextSocketAction::CLOSE
end

#need_data ⇒ Object 



252
253
254
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 252

def need_data()
  return @state == STATE_READ_DATA
end

#reset ⇒ Object

implements Reusable



48
49
50
51
52
53
54
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 48

def reset()
  super
  reset_state()
  @req_command = nil
  @keeping = false
  @cur_tour_id = 0
end

#send_end_tour(tur, keep_alive, &callback) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 78

def send_end_tour(tur, keep_alive, &callback)
  BayLog.debug("%s endTour: tur=%s keep=%s", @ship, tur, keep_alive)
  cmd = CmdEndResponse.new()
  cmd.reuse = keep_alive

  ensure_func = lambda do
    if !keep_alive
      command_packer.end(@ship)
    end
  end

  begin
    command_packer.post(@ship, cmd) do
      BayLog.debug("%s call back in sendEndTour: tur=%s keep=%s", self, tur, keep_alive)
      ensure_func.call()
      callback.call()
    end
  rescue IOError => e
    BayLog.debug("%s post failed in sendEndTour: tur=%s keep=%s", self, tur, keep_alive)
    ensure_func.call()
    raise e
  end
end

#send_req_protocol_error(e) ⇒ Object 



102
103
104
105
106
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 102

def send_req_protocol_error(e)
  tur = @ship.get_error_tour()
  tur.res.send_error(Tour::TOUR_ID_NOCHECK, HttpStatus::BAD_REQUEST, e.message, e)
  return true
end

#send_res_content(tur, bytes, ofs, len, &lis) ⇒ Object 



73
74
75
76
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 73

def send_res_content(tur, bytes, ofs, len, &lis)
  cmd = CmdSendBodyChunk.new(bytes, ofs, len);
  @command_packer.post(ship, cmd, &lis);
end

#send_res_headers(tur) ⇒ Object

implements InboundHandler



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/baykit/bayserver/docker/ajp/ajp_inbound_handler.rb', line 59

def send_res_headers(tur)
  chunked = false
  cmd = CmdSendHeaders.new()
  tur.res.headers.names.each do |name|
    tur.res.headers.values(name).each do |value|
      cmd.add_header(name, value)
    end
  end
  cmd.status = tur.res.headers.status
  command_packer.post(@ship, cmd)

  BayLog.debug("%s send header: content-length=%d", self, tur.res.headers.content_length())
end