Class: Baykit::BayServer::Docker::Http::H1::H1WarpHandler

Inherits:
Object
  • Object
show all
Includes:
Agent, Common, Common::WarpHandler, Command, H1Handler, Protocol, Tours, Util
Defined in:
lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb

Defined Under Namespace

Classes: WarpProtocolHandlerFactory

Constant Summary collapse

STATE_READ_HEADER = 
1
STATE_READ_CONTENT = 
2
STATE_FINISHED = 
3
FIXED_WARP_ID = 
1

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from H1Handler

#on_protocol_error

Constructor Details

#initialize ⇒ H1WarpHandler

Returns a new instance of H1WarpHandler.



49
50
51
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 49

def initialize()
  reset()
end

Instance Attribute Details

#protocol_handler ⇒ Object (readonly)

Returns the value of attribute protocol_handler.



46
47
48
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 46

def protocol_handler
  @protocol_handler
end

#state ⇒ Object (readonly)

Returns the value of attribute state.



47
48
49
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 47

def state
  @state
end

Instance Method Details

#handle_content(cmd) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 202

def handle_content(cmd)
  tur = ship.get_tour(FIXED_WARP_ID)
  wdat = WarpData.get(tur)
  BayLog.debug("%s handleContent len=%d posted%d contLen=%d", wdat, cmd.len, tur.res.bytes_posted, tur.res.bytes_limit);

  if @state != STATE_READ_CONTENT
    raise ProtocolException.new("Content command not expected")
  end

  available = tur.res.send_res_content(Tour::TOUR_ID_NOCHECK, cmd.buf, cmd.start, cmd.len)
  if tur.res.bytes_posted == tur.res.bytes_limit
    end_res_content(tur)
    return NextSocketAction::CONTINUE
  elsif !available
    return NextSocketAction::SUSPEND
  else
    NextSocketAction::CONTINUE
  end
end

#handle_end_content(cmd) ⇒ Object

Raises:

  • (Sink) 


222
223
224
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 222

def handle_end_content(cmd)
  raise Sink.new()
end

#handle_header(cmd) ⇒ Object

Implements H1CommandHandler



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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 158

def handle_header(cmd)
  tur = ship.get_tour(FIXED_WARP_ID)
  wdat = WarpData.get(tur)
  BayLog.debug("%s handleHeader status=%d", wdat, cmd.status);
  ship.keeping = false

  if @state == STATE_FINISHED
    change_state(STATE_READ_HEADER)
  end

  if @state != STATE_READ_HEADER
    raise ProtocolException.new("Header command not expected: state=%d", @state)
  end

  if BayServer.harbor.trace_header
    BayLog.info("%s warp_http: resStatus: %d", wdat, cmd.status)
  end

  cmd.headers.each do |nv|
    tur.res.headers.add(nv[0], nv[1])
    if BayServer.harbor.trace_header
      BayLog.info("%s warp_http: resHeader: %s=%s", wdat, nv[0], nv[1]);
    end
  end

  tur.res.headers.status = cmd.status
  res_cont_len = tur.res.headers.content_length
  tur.res.send_headers(Tour::TOUR_ID_NOCHECK)

  BayLog.debug("%s contLen in header: %d", wdat, res_cont_len)
  if res_cont_len == 0 || cmd.status == HttpStatus::NOT_MODIFIED
    end_res_content(tur)
  else
    change_state(STATE_READ_CONTENT)
    sid = ship.id()
    tur.res.set_consume_listener do |len, resume|
      if resume
        ship.resume_read(sid)
      end
    end
  end
  return NextSocketAction::CONTINUE
end

#init(proto_handler) ⇒ Object 



53
54
55
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 53

def init(proto_handler)
  @protocol_handler = proto_handler
end

#new_warp_data(warp_id) ⇒ Object 



146
147
148
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 146

def new_warp_data(warp_id)
  return WarpData.new(ship, warp_id)
end

#next_warp_id ⇒ Object

Implements WarpHandler



142
143
144
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 142

def next_warp_id
  return H1WarpHandler::FIXED_WARP_ID
end

#req_finished ⇒ Object 



226
227
228
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 226

def req_finished
  return @state == STATE_FINISHED
end

#reset ⇒ Object

Implements Reusable



66
67
68
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 66

def reset
  reset_state
end

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



133
134
135
136
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 133

def send_end_tour(tur, keep_alive, &lis)
  cmd = CmdEndContent.new()
  ship.post(cmd, &lis)
end

#send_res_content(tur, buf, start, len, &callback) ⇒ Object 



128
129
130
131
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 128

def send_res_content(tur, buf, start, len, &callback)
  cmd = CmdContent.new(buf, start, len)
  ship.post(cmd, &callback)
end

#send_res_headers(tur) ⇒ Object

Implements TourHandler



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
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 74

def send_res_headers(tur)
  twn = tur.town

  twn_path = twn.name
  if !twn_path.end_with?("/")
    twn_path += "/"
  end

  new_uri = ship.docker.warp_base + tur.req.uri[twn_path.length .. -1]
  cmd = CmdHeader.new_req_header(tur.req.method, new_uri, "HTTP/1.1")

  tur.req.headers.names.each do |name|
    tur.req.headers.values(name).each do |value|
      cmd.add_header(name, value)
    end
  end

  if tur.req.headers.contains(Headers::X_FORWARDED_FOR)
    cmd.set_header(Headers::X_FORWARDED_FOR, tur.req.headers.get(Headers::X_FORWARDED_FOR))
  else
    cmd.set_header(Headers::X_FORWARDED_FOR, tur.req.remote_address)
  end

  if tur.req.headers.contains(Headers::X_FORWARDED_PROTO)
    cmd.set_header(Headers::X_FORWARDED_PROTO, tur.req.headers.get(Headers::X_FORWARDED_PROTO))
  else
    cmd.set_header(Headers::X_FORWARDED_PROTO, tur.is_secure ? "https" : "http")
  end

  if tur.req.headers.contains(Headers::X_FORWARDED_PORT)
    cmd.set_header(Headers::X_FORWARDED_PORT, tur.req.headers.get(Headers::X_FORWARDED_PORT))
  else
    cmd.set_header(Headers::X_FORWARDED_PORT, tur.req.server_port.to_s)
  end

  if tur.req.headers.contains(Headers::X_FORWARDED_HOST)
    cmd.set_header(Headers::X_FORWARDED_HOST, tur.req.headers.get(Headers::X_FORWARDED_HOST))
  else
    cmd.set_header(Headers::X_FORWARDED_HOST, tur.req.headers.get(Headers::HOST))
  end

  cmd.set_header(Headers::HOST, "#{ship.docker.host}:#{ship.docker.port}")
  cmd.set_header(Headers::CONNECTION, "Keep-Alive")

  if BayServer.harbor.trace_header
    cmd.headers.each do |kv|
      BayLog.info("%s warp_http reqHdr: %s=%s", tur, kv[0], kv[1])
    end
  end


  ship.post(cmd)
end

#to_s ⇒ Object 



57
58
59
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 57

def to_s
  return ship.to_s
end

#verify_protocol(proto) ⇒ Object 



150
151
152
 
# File 'lib/baykit/bayserver/docker/http/h1/h1_warp_handler.rb', line 150

def verify_protocol(proto)

end