src: Add h2load, benchmarking tool for HTTP/2 and SPDY

src/Makefile.am

@@ -51,7 +51,7 @@ LDADD = \
 
 if ENABLE_APP
 
-bin_PROGRAMS += nghttp nghttpd nghttpx
+bin_PROGRAMS += nghttp nghttpd nghttpx h2load
 
 HELPER_OBJECTS = util.cc http2.cc timegm.c app_helper.cc
 HELPER_HFILES = util.h http2.h timegm.h app_helper.h nghttp2_config.h
@@ -69,6 +69,14 @@ nghttp_SOURCES = ${HELPER_OBJECTS} ${HELPER_HFILES} nghttp.cc \
 nghttpd_SOURCES = ${HELPER_OBJECTS} ${HELPER_HFILES} nghttpd.cc \
 	HttpServer.cc HttpServer.h
 
+h2load_SOURCES = util.cc util.h http2.cc http2.h h2load.cc h2load.h \
+	h2load_session.h \
+	h2load_http2_session.cc h2load_http2_session.h
+
+if HAVE_SPDYLAY
+h2load_SOURCES += h2load_spdy_session.cc h2load_spdy_session.h
+endif # HAVE_SPDYLAY
+
 NGHTTPX_SRCS = \
 	util.cc util.h http2.cc http2.h timegm.c timegm.h base64.h \
 	app_helper.cc app_helper.h \

src/h2load.h

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef H2LOAD_H
+#define H2LOAD_H
+
+#include "nghttp2_config.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <memory>
+
+#include <nghttp2/nghttp2.h>
+
+#include <event.h>
+#include <event2/event.h>
+
+#include <openssl/ssl.h>
+
+namespace h2load {
+
+class Session;
+
+struct Config {
+  std::vector<nghttp2_nv> nva;
+  std::vector<const char*> nv;
+  std::string scheme;
+  std::string host;
+  std::string path;
+  addrinfo *addrs;
+  size_t nreqs;
+  size_t nclients;
+  size_t nworkers;
+  // The maximum number of concurrent streams per session.
+  size_t max_concurrent_streams;
+  size_t window_bits;
+  size_t connection_window_bits;
+  uint16_t port;
+  bool verbose;
+
+  Config();
+  ~Config();
+};
+
+struct Stats {
+  // The total number of requests
+  size_t req_todo;
+  // The number of requests issued so far
+  size_t req_started;
+  // The number of requests finished
+  size_t req_done;
+  // The number of requests marked as success. This is subset of
+  // req_done.
+  size_t req_success;
+  // The number of requests failed. This is subset of req_done.
+  size_t req_failed;
+  // The number of requests failed due to network errors. This is
+  // subset of req_failed.
+  size_t req_error;
+  // The number of bytes received on the "wire". If SSL/TLS is used,
+  // this is the number of decrypted bytes the application received.
+  int64_t bytes_total;
+  // The number of bytes received in HEADERS frame payload.
+  int64_t bytes_head;
+  // The number of bytes received in DATA frame.
+  int64_t bytes_body;
+  // The number of each HTTP status category, status[i] is status code
+  // in the range [i*100, (i+1)*100).
+  size_t status[6];
+};
+
+enum ClientState {
+  CLIENT_IDLE,
+  CLIENT_CONNECTED
+};
+
+struct Client;
+
+struct Worker {
+  std::vector<std::unique_ptr<Client>> clients;
+  Stats stats;
+  event_base *evbase;
+  SSL_CTX *ssl_ctx;
+  Config *config;
+  size_t progress_interval;
+  bool term_timer_started;
+
+  Worker(SSL_CTX *ssl_ctx, Config *config);
+  ~Worker();
+  void run();
+  void schedule_terminate();
+  void terminate_session();
+};
+
+struct Stream {
+  int status_success;
+  Stream();
+};
+
+struct Client {
+  std::unordered_map<int32_t, Stream> streams;
+  std::unique_ptr<Session> session;
+  Worker *worker;
+  SSL *ssl;
+  bufferevent *bev;
+  addrinfo *next_addr;
+  ClientState state;
+
+  Client(Worker *worker);
+  ~Client();
+  int connect();
+  void disconnect();
+  void submit_request();
+  void process_abandoned_streams();
+  void report_progress();
+  void terminate_session();
+  int on_connect();
+  int on_read();
+  int on_write();
+  void on_request(int32_t stream_id);
+  void on_header(int32_t stream_id,
+                 const uint8_t *name, size_t namelen,
+                 const uint8_t *value, size_t valuelen);
+  void on_stream_close(int32_t stream_id, bool success);
+};
+
+} // namespace h2load
+
+#endif // H2LOAD_H

src/h2load_http2_session.cc

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "h2load_http2_session.h"
+
+#include "h2load.h"
+
+namespace h2load {
+
+Http2Session::Http2Session(Client *client)
+  : client_(client),
+    session_(nullptr)
+{}
+
+Http2Session::~Http2Session()
+{
+  nghttp2_session_del(session_);
+}
+
+namespace {
+int before_frame_send_callback
+(nghttp2_session *session, const nghttp2_frame *frame, void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  if(frame->hd.type == NGHTTP2_HEADERS &&
+     frame->headers.cat == NGHTTP2_HCAT_REQUEST) {
+    client->on_request(frame->hd.stream_id);
+  }
+  return 0;
+}
+} // namespace
+
+namespace {
+int on_header_callback(nghttp2_session *session,
+                       const nghttp2_frame *frame,
+                       const uint8_t *name, size_t namelen,
+                       const uint8_t *value, size_t valuelen,
+                       void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  if(frame->hd.type != NGHTTP2_HEADERS ||
+     frame->headers.cat != NGHTTP2_HCAT_RESPONSE) {
+    return 0;
+  }
+  client->on_header(frame->hd.stream_id, name, namelen, value, valuelen);
+  return 0;
+}
+} // namespace
+
+namespace {
+int on_frame_recv_callback(nghttp2_session *session,
+                           const nghttp2_frame *frame,
+                           void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  if(frame->hd.type != NGHTTP2_HEADERS ||
+     frame->headers.cat != NGHTTP2_HCAT_RESPONSE) {
+    return 0;
+  }
+  client->worker->stats.bytes_head += frame->hd.length;
+  return 0;
+}
+} // namespace
+
+namespace {
+int on_data_chunk_recv_callback
+(nghttp2_session *session, uint8_t flags, int32_t stream_id,
+ const uint8_t *data, size_t len, void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  client->worker->stats.bytes_body += len;
+  return 0;
+}
+} // namespace
+
+namespace {
+int on_stream_close_callback
+(nghttp2_session *session, int32_t stream_id, nghttp2_error_code error_code,
+ void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  client->on_stream_close(stream_id, error_code == NGHTTP2_NO_ERROR);
+  return 0;
+}
+} // namespace
+
+void Http2Session::on_connect()
+{
+  nghttp2_session_callbacks callbacks = {0};
+  callbacks.before_frame_send_callback = before_frame_send_callback;
+  callbacks.on_frame_recv_callback = on_frame_recv_callback;
+  callbacks.on_data_chunk_recv_callback = on_data_chunk_recv_callback;
+  callbacks.on_stream_close_callback = on_stream_close_callback;
+  callbacks.on_header_callback = on_header_callback;
+
+  nghttp2_session_client_new(&session_, &callbacks, client_);
+
+  nghttp2_settings_entry iv[2];
+  iv[0].settings_id = NGHTTP2_SETTINGS_ENABLE_PUSH;
+  iv[0].value = 0;
+  iv[1].settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
+  iv[1].value = (1 << client_->worker->config->window_bits) - 1;
+  nghttp2_submit_settings(session_, NGHTTP2_FLAG_NONE, iv,
+                          sizeof(iv) / sizeof(iv[0]));
+
+  auto extra_connection_window =
+    (1 << client_->worker->config->connection_window_bits) - 1
+    - NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;
+  if(extra_connection_window != 0) {
+    nghttp2_submit_window_update(session_, NGHTTP2_FLAG_NONE, 0,
+                                 extra_connection_window);
+  }
+
+  bufferevent_write(client_->bev, NGHTTP2_CLIENT_CONNECTION_HEADER,
+                    NGHTTP2_CLIENT_CONNECTION_HEADER_LEN);
+}
+
+void Http2Session::submit_request()
+{
+  nghttp2_submit_request(session_, 0,
+                         client_->worker->config->nva.data(),
+                         client_->worker->config->nva.size(),
+                         nullptr, nullptr);
+}
+
+ssize_t Http2Session::on_read()
+{
+  int rv;
+  auto input = bufferevent_get_input(client_->bev);
+  auto inputlen = evbuffer_get_length(input);
+  auto mem = evbuffer_pullup(input, -1);
+
+  rv = nghttp2_session_mem_recv(session_, mem, inputlen);
+  if(rv < 0) {
+    return -1;
+  }
+  evbuffer_drain(input, rv);
+  return rv;
+}
+
+int Http2Session::on_write()
+{
+  int rv;
+  auto output = bufferevent_get_output(client_->bev);
+  for(;;) {
+    const uint8_t *data;
+    auto datalen = nghttp2_session_mem_send(session_, &data);
+
+    if(datalen < 0) {
+      return -1;
+    }
+    if(datalen == 0) {
+      break;
+    }
+    rv = evbuffer_add(output, data, datalen);
+    if(rv == -1) {
+      return -1;
+    }
+  }
+  if(nghttp2_session_want_read(session_) == 0 &&
+     nghttp2_session_want_write(session_) == 0 &&
+     evbuffer_get_length(output) == 0) {
+    return -1;
+  }
+  return 0;
+}
+
+void Http2Session::terminate()
+{
+  nghttp2_session_terminate_session(session_, NGHTTP2_NO_ERROR);
+}
+
+} // namespace h2load

src/h2load_http2_session.h

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef H2LOAD_HTTP2_SESSION_H
+#define H2LOAD_HTTP2_SESSION_H
+
+#include "h2load_session.h"
+
+#include <nghttp2/nghttp2.h>
+
+namespace h2load {
+
+class Client;
+
+class Http2Session : public Session {
+public:
+  Http2Session(Client *client);
+  virtual ~Http2Session();
+  virtual void on_connect();
+  virtual void submit_request();
+  virtual ssize_t on_read();
+  virtual int on_write();
+  virtual void terminate();
+private:
+  Client *client_;
+  nghttp2_session *session_;
+};
+
+} // namespace h2load
+
+#endif // H2LOAD_HTTP2_SESSION_H

src/h2load_session.h

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef H2LOAD_SESSION_H
+#define H2LOAD_SESSION_H
+
+#include "nghttp2_config.h"
+
+#include <sys/types.h>
+
+namespace h2load {
+
+class Session {
+public:
+  virtual ~Session() {}
+  // Called when the connection was made.
+  virtual void on_connect() = 0;
+  // Called when one request must be issued.
+  virtual void submit_request() = 0;
+  // Called when incoming bytes are available. The subclass has to
+  // return the number of bytes read.
+  virtual ssize_t on_read() = 0;
+  // Called when write is available. Returns 0 on success, otherwise
+  // return -1.
+  virtual int on_write() = 0;
+  // Called when the underlying session must be terminated.
+  virtual void terminate() = 0;
+};
+
+} // namespace h2load
+
+#endif // H2LOAD_SESSION_H

src/h2load_spdy_session.cc

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "h2load_spdy_session.h"
+
+#include "h2load.h"
+
+namespace h2load {
+
+SpdySession::SpdySession(Client *client, uint16_t spdy_version)
+  : client_(client),
+    session_(nullptr),
+    spdy_version_(spdy_version)
+{}
+
+SpdySession::~SpdySession()
+{
+  spdylay_session_del(session_);
+}
+
+namespace {
+void before_ctrl_send_callback
+(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
+ void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  if(type != SPDYLAY_SYN_STREAM) {
+    return;
+  }
+  client->on_request(frame->syn_stream.stream_id);
+}
+} // namespace
+
+namespace {
+void on_ctrl_recv_callback(spdylay_session *session,
+                           spdylay_frame_type type,
+                           spdylay_frame *frame,
+                           void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  if(type != SPDYLAY_SYN_REPLY) {
+    return;
+  }
+  for(auto p = frame->syn_reply.nv; *p; p += 2) {
+    auto name = *p;
+    auto value = *(p + 1);
+    client->on_header(frame->syn_reply.stream_id,
+                      reinterpret_cast<const uint8_t*>(name),
+                      strlen(name),
+                      reinterpret_cast<const uint8_t*>(value),
+                      strlen(value));
+  }
+  client->worker->stats.bytes_head += frame->syn_reply.hd.length;
+}
+} // namespace
+
+namespace {
+void on_data_chunk_recv_callback
+(spdylay_session *session, uint8_t flags, int32_t stream_id,
+ const uint8_t *data, size_t len, void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  client->worker->stats.bytes_body += len;
+}
+} // namespace
+
+namespace {
+void on_stream_close_callback
+(spdylay_session *session, int32_t stream_id, spdylay_status_code status_code,
+ void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  client->on_stream_close(stream_id, status_code == SPDYLAY_OK);
+}
+} // namespace
+
+namespace {
+ssize_t send_callback(spdylay_session *session,
+                      const uint8_t *data, size_t length, int flags,
+                      void *user_data)
+{
+  auto client = static_cast<Client*>(user_data);
+  auto output = bufferevent_get_output(client->bev);
+  evbuffer_add(output, data, length);
+  return length;
+}
+} //namespace
+
+void SpdySession::on_connect()
+{
+  spdylay_session_callbacks callbacks = {0};
+  callbacks.send_callback = send_callback;
+  callbacks.before_ctrl_send_callback = before_ctrl_send_callback;
+  callbacks.on_data_chunk_recv_callback = on_data_chunk_recv_callback;
+  callbacks.on_stream_close_callback = on_stream_close_callback;
+  callbacks.on_ctrl_recv_callback = on_ctrl_recv_callback;
+
+  spdylay_session_client_new(&session_, spdy_version_, &callbacks, client_);
+
+  spdylay_settings_entry iv[1];
+  iv[0].settings_id = SPDYLAY_SETTINGS_INITIAL_WINDOW_SIZE;
+  iv[0].flags = SPDYLAY_ID_FLAG_SETTINGS_NONE;
+  iv[0].value = (1 << client_->worker->config->window_bits);
+  spdylay_submit_settings(session_, SPDYLAY_FLAG_SETTINGS_NONE, iv,
+                          sizeof(iv) / sizeof(iv[0]));
+}
+
+void SpdySession::submit_request()
+{
+  spdylay_submit_request(session_, 0, client_->worker->config->nv.data(),
+                         nullptr, nullptr);
+}
+
+ssize_t SpdySession::on_read()
+{
+  int rv;
+  auto input = bufferevent_get_input(client_->bev);
+  auto inputlen = evbuffer_get_length(input);
+  auto mem = evbuffer_pullup(input, -1);
+
+  rv = spdylay_session_mem_recv(session_, mem, inputlen);
+  if(rv < 0) {
+    return -1;
+  }
+  evbuffer_drain(input, rv);
+  return rv;
+}
+
+int SpdySession::on_write()
+{
+  int rv;
+  rv = spdylay_session_send(session_);
+  if(rv != 0) {
+    return -1;
+  }
+  if(spdylay_session_want_read(session_) == 0 &&
+     spdylay_session_want_write(session_) == 0 &&
+     evbuffer_get_length(bufferevent_get_output(client_->bev)) == 0) {
+    return -1;
+  }
+  return 0;
+}
+
+void SpdySession::terminate()
+{
+  spdylay_session_fail_session(session_, SPDYLAY_OK);
+}
+
+} // namespace h2load

src/h2load_spdy_session.h

+/*
+ * nghttp2 - HTTP/2.0 C Library
+ *
+ * Copyright (c) 2014 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef H2LOAD_SPDY_SESSION_H
+#define H2LOAD_SPDY_SESSION_H
+
+#include "h2load_session.h"
+
+#include <spdylay/spdylay.h>
+
+namespace h2load {
+
+class Client;
+
+class SpdySession : public Session {
+public:
+  SpdySession(Client *client, uint16_t spdy_version);
+  virtual ~SpdySession();
+  virtual void on_connect();
+  virtual void submit_request();
+  virtual ssize_t on_read();
+  virtual int on_write();
+  virtual void terminate();
+private:
+  Client *client_;
+  spdylay_session *session_;
+  uint16_t spdy_version_;
+};
+
+} // namespace h2load
+
+#endif // H2LOAD_SPDY_SESSION_H