👨‍🚀 🍉 🏇🏾 テストタスクとしてのWebServer 🔯 🏏 📈

それがすべて始まった方法

現在の私の仕事はデスクトップアプリケーションに関連しているという事実にもかかわらず、私は最近「サーバーテクノロジー」に興味を持っています。インターネットをサーフィンしたり、man'ovを読んだり、自分用にサーバーのようなものを書き込もうとしたりする人もいます。明確な目標がないため、これが最近行われたすべてです。おもしろいタスクを思いついたら、あなたのスキルレベルをそれほど悪くはしないでください。

仕事から退屈になったある時点で、よく知られている求人検索リソースの1つをチェックしました。市場を見るのは気にしないことです。突然、興味深いことが浮かび上がります。「おそらくあなたに興味があるでしょう。」そのような提案の中で、テストタスクを伴う提案が来ました。テストタスクは、HTTPプロトコルの実装を使用して、LinuxでC ++でWebServerを作成することです。気取らない...

テストタスクのフレーズをGoogleに導入したところ、 RSDNフォーラムで最短のテストタスクではなく、これに関するレビューを見つけました。タスクは、私のメーラーにある1対1でした。割り当てとして、彼はしませんでした。原則は単純です。テストタスクに価値がある場合は、4時間以内の作業時間で設計する必要があります。しかし、読み聞かせられ、場所で試されたすべてを試すことは興味深いことでした。これがインセンティブになりました。興味深い問題の声明。採用担当者からのものであるため、このタスクがどのオフィスに属しているかは言えませんが、それほど重要でもありません。

この記事では、このトピックで見つけたアプローチと関連APIを調べます。さまざまなアプローチとツールを使用してWebServerのいくつかの実装を提供し、受け取った「クラフト」の比較テストを実施しました。この記事は「ひげを生やした」サーバーライターを対象とはしていませんが、レビューとして（テストだけでなく）同様のタスクに遭遇する人が役に立つかもしれません。記事を書くことは経験を共有することだけでなく、それを自分で補充することになるかもしれないので、私はみんな、特に「ひげを生やした」サーバーライターから建設的なコメントをうれしく思います...

APIとライブラリの概要

サーバー側のスクリプトツールを検討した結果、API * nix of systems、Windows API（このプラットフォームはこのタスクの目的ではありませんが、表示されません）、およびboost.asioやlibeventなどのライブラリがありました。

Berkeleyソケットは、普遍的でポータブルなメカニズムですが、完全に明確に移植されているわけではありません。そのため、一部のプラットフォームではソケットを閉じるために近く、一部のクローズソケットでは。ライブラリを初期化する必要があるもの（Windows-WSAStartup / WSACleanup）、そうでないものもあります。どこかでは、ソケット記述子はint型で、どこかではSOCKETとその他の小さな違いです。 pImplなどのすべての種類のクロスプラットフォームプログラミングアプローチを適用しない場合、同じコードは機能せず、多くの場合、異なるプラットフォームで同じ方法でビルドされます。これらの小さなものはすべて、 boost.asio 、 libeventなどのライブラリに隠されています。さらに、このようなライブラリは、対応するプラットフォームのより具体的なAPIメソッドを使用して、ソケットを使用した最適な作業を実装し、プラットフォームのヒントなしに便利なインターフェイスをユーザーに提供します。

サーバーの作業を非常に一般化した方法で実行すると、次の一連のアクションが発生します。

ソケットを作成する
ソケットをネットワークインターフェイスにバインドする
特定のネットワークインターフェイスにバインドされたソケットをリッスンする
着信接続を受け入れる
ソケットのイベントに応答する

5番目を除くすべてのポイントは比較的類似しており、ほとんど関心がありませんが、ソケットで発生するイベントに応答するための多くのメカニズムがあり、それらのほとんどは各プラットフォームに固有です。

Windowsを見ると、次の方法がわかります。

選択を使用します。基本的に、他のプラットフォームのコードとの互換性のために、ここではそれ以上の利点はありません。
WSAAsyncSelect-ウィンドウ化されたアプリケーションがソケット上のイベントをウィンドウ化されたキューに送信するように設計されています。速くはなく、サーバーコードメカニズムとしては興味深いものではありません。
WSAEventSelectは、ネットワークインターフェイス上のイベントオブジェクトを処理します。すでにより魅力的なツール。つまり同時にサービスを提供する接続が数百を超えないようにサーバーを計画する場合、これはパフォーマンス/開発速度の基準によると最適なメカニズムです。
I / Oの重複はWSAEventSelectよりも高速なメカニズムですが、開発するのも面倒です。
I / O完了ポート-高負荷サーバーアプリケーション用。

Windows用のネットワークソフトウェアの開発に関する優れた書籍があります-「Microsoft Windowsネットワークでのプログラミング」。

* nixシステムを見ると、イベントセレクターの小さなセットもあります。

同じ選択。そして再び、彼の役割は他のプラットフォームとの互換性です。また、監視しているソケットのいずれかでイベントが発生するとトリガーされる（制御を返す）ため、高速ではありません。このような操作の後、すべてを実行して、イベントが発生したソケットを確認する必要があります。要約：1つの操作は、観測されたソケットのプール全体で実行されます。
pollはより高速なメカニズムですが、監視用の多数のソケット用に設計されていません。
epoll（Linuxシステム）とkqueue（FreeBSD）はほぼ同じメカニズムですが、一部のフォーラムの猛烈なFreeBSDファンはkqueueの方がはるかに強力だと強く主張しています。私たちは聖戦を助長しません...これらのメカニズムは、* nixシステムで負荷の高いサーバーアプリケーションを作成する際の主なものと考えることができます。動作原理とその尊厳を簡単に説明すると、何かが発生したソケットのみに関連する一定量の情報が返され、すべてを実行して何がどこで発生したかを確認する必要はありません。また、これらのメカニズムは、同時にサービスされる多数の接続用に設計されています。

記述子のイベントを待機する機能に加えて、さらに小さいが非常に便利なものがいくつかあります。

sendfile（Linux）およびTransmitFile（Windows）を使用すると、「送信元」および「送信先」のいくつかの記述子をフィードしてデータを送信できます。 HTTPサーバーでは、ファイルを転送する必要がある場合に非常に便利です。これは、パフォーマンスにプラスの影響を与える、バッファーの割り当てと読み取り/書き込み関数の呼び出しが不要になるためです。
aio-特定の量の作業をオペレーティングシステムに転送できます。これにより、ファイル記述子で非同期操作を実行できるようになります。たとえば、システムにバッファーを伝え、シグナルをどのように終了するかをこのファイル記述子に書き込みます（読み取りと同様）。
Neiglアルゴリズムは、バッファリングの遅延なしにネットワークにデータを少しずつ送信する必要があるアプリケーションを作成するときに役立ちますが、常に役立つとは限りません。 HTTPサーバーなどのアプリケーションでは、システムに送信データをバッファーし、可能な限り有用な情報とともにTCPフレームに送信するように指示することをお勧めします（これには、TCP_CORKなどのソケットオプションを使用できます）。
そしてもちろん、ノンブロッキングソケット。コメントなし...
また、writev（nix）などの関数（およびWindowsの同様のWSA関数）を使用すると、複数のバッファーを一度に送信できます。これは、HTTPパケットヘッダーとそれに添付されたデータを送信し、同時にシステムコールの数を節約する必要がある場合に便利です。

ライブラリーをスターター用のコードとともに使用することをお勧めします。これについては、例としてboost.asioとlibeventを使用して行います。 boost.asioはネットワークアプリケーションの開発を大幅に簡素化します。libeventはサーバークラシックです。

Epollの実装

epoll、poll、selectのネットワークイベントに応答するためにどのようなメカニズムを選択したとしても、他にも多くのニュアンスがあります。

マルチスレッドサーバーを実装する際の最初の質問の1つは、スレッド数の選択です。かつてトレーニングや疑似戦闘の目的で「ソケットサーバー」をすばやく組み立てる必要があった人のほとんどは、「1つの接続-1つのスレッド」という戦略を選択しました。このアプローチには長所と短所があります。最大のプラスは、開発の容易さです。多くの欠点があります：大量のシステムリソース、多くの同期アクション（コード、何かと同期する何か）。ただし、セッション間に特別な共通部分がないため、このアプローチは同期の点でHTTPサーバーにとって悪いことではありません。しかし、開発の単純さにもかかわらず、私はその実装のためにこの戦略を考慮しませんでした。スレッド数の最適な選択にはさまざまな推奨事項があります。これは、システム内のプロセッサ/プロセッサコアの数で、同じ数ですが、特定の係数があります。提案された実装では、ワーカースレッドの数は、サーバーの起動時にユーザーによって設定されるオプションのパラメーターです。私にとっては、ワークフローの数はプロセッサ/コアの数に2を掛けたものに等しいと判断されました。
現在のコンテキストでは、ワークフローはユーザー要求を処理するスレッドとして理解される必要があります。これらのフローに加えて、リスニングストリームとメインストリームの2つが含まれていました。リスニングストリーム-サーバーソケットをリッスンし、着信接続を受け入れ、処理のためのワークフローのキューに入れられます。メインスレッド-サーバーを起動し、ユーザーからの特定のアクションを待って停止します。

この例を実装するときに興味を持った2番目の質問は、epollを使用する際のフローとネットワークイベントの処理方法です。私が最初に思いついたのは、1つのスレッドでepollによって監視されているすべてのイベントに反応し、それらを他のスレッド（ワーカー）で処理し、特定のキューに渡すことでした。つまり 1つのスレッドは、リスニングソケット上の着信イベントと、受信した接続へのデータの到着に関するイベントと、閉じられている接続に関するイベントの両方を監視します。イベントを取得し、キューに入れ、ワーカースレッドに通知し、新しい接続を受け入れるためにacceptと呼ばれるワーカースレッドを追加し、epoll、読み取り、書き込みを追加し、接続の監視ソケットのプールを閉じます。ソケットからのデータの読み取りなど、1つのイベントの処理中に、ソケットを閉じることに関するイベントがこのソケットのキューに既にある可能性があるため、決定は間違っています。もちろん、読み取りはエラーで失敗しますが、接続に関連するすべてのリソースをクリアする手順にはなりませんが、キューからこのイベントを減算する場合のみです。私の実装では、多くのソケットクロージャイベントが失われました。実装はより複雑になり、同期の場所の数が増え、奇妙な状況ではドロップが発生しました。滝は別の理由でした。 epollイベントの構造内の各ソケットでは、ユーザーデータとして、ポインターがセッションオブジェクトにアタッチされ、クライアントオブジェクトが閉じられるまで、クライアントとのすべての作業を行いました。イベント処理のシーケンスがより複雑になったため、ユーザーデータとして関連付けられたオブジェクトが既に削除されたため（たとえば、セッションが外部イベントによってではなく、内部のセッション自体のロジックによって閉じられたとき）、これにより、既に壊れたポインターでの処理。最初のアイデアから「熊手で」そのような経験を受け取ったので、別の戦略が採用されました：epollによるメインリスニングストリームは、リスニングソケットのイベントにのみ応答し、着信接続を受け入れ、その数が待機キューに許可されている場合、それらを閉じますそれ以外の場合、受信した接続を処理のためにキューに入れます。ワークフローはこのキューを差し引いて、このソケットをepollセットに入れます。ワークフローはepoll記述子で動作し、すべてが1つのストリームのフレームワーク内で行われます：epollへの配置、データ到着のイベントへの反応、読み取り/書き込み、終了（ハンドルが閉じられると、epollからの削除はシステムレベルで自動的に行われます）。このような組織の結果として、着信接続のキューを保護する同期プリミティブは1つだけです。一方では、リスニングストリームのみがこのキューに書き込み、他方では、受信された接続のために受信されたフローが選択されます。 1つ少ない問題。 epoll構造のユーザーデータを使用したセッションオブジェクトへのポインターのバインドを放棄します。解決策：連想配列を使用します。キーはソケット記述子であり、データはセッションオブジェクトです。これにより、イベントが発生したとき、epollイベントからユーザーデータを取得する機会があるときだけでなく、何らかのロジックに従って、たとえばタイムアウトによって接続を閉じる必要があるとき（接続プールが利用可能）にセッションを操作できます。

最初のオプションは、完全に1つのファイルに記述され、C＃/ Java開発者のスタイルで（宣言と定義に分割することなく）、1800行以上のコードがありました。テストタスクには多すぎます。HTTPプロトコルの実装が最小限であるという事実にもかかわらず、他の何もせずにHTTPヘッダーのパラメーターを最小限で処理してGET / HEADを処理するための最小限です。それはポイントではありません。繰り返しになりますが、テストタスクは単に何かを試す「キック」でした。このソリューションでの私の主な関心は、HTTPプロトコルの実装ではなく、マルチスレッドサーバーの実装、接続とセッションの管理でした（セッションは、接続に関連する処理アルゴリズムを持つ論理データ構造として理解できます）。
この巨大なファイルを破壊し、いくつかの場所で実装をとかすと、次のようになります。

class TCPServer : private Common::NonCopyable { public: TCPServer(InetAddress const &locAddr, int backlog, int maxThreadsCount, int maxConnectionsCount, UserSessionCreator sessionCreator); private: typedef std::tr1::shared_ptr<Common::IDisposable> IDisposablePtr; typedef std::vector<IDisposablePtr> IDisposablePool; Private::ClientItemQueuePtr AcceptedItems; IDisposablePool Threads; };

これはおそらく、私が記述しなければならなかった最短のサーバークラス実装です。このクラスは、リスナーと複数のワーカーの複数のスレッドのみを作成し、それらのホルダーです。

実装

 TCPServer::TCPServer(InetAddress const &locAddr, int backlog, int maxThreadsCount, int maxConnectionsCount, UserSessionCreator sessionCreator) : AcceptedItems(new Private::ClientItemQueue(backlog)) { int EventsCount = maxConnectionsCount / maxThreadsCount; for (int i = 0 ; i < maxThreadsCount ; ++i) { Threads.push_back(IDisposablePtr(new Private::WorkerThread( EventsCount + (i <= maxThreadsCount - 1 ? 0 : maxConnectionsCount % maxThreadsCount), AcceptedItems ))); } Threads.push_back(IDisposablePtr(new Private::ListenThread(locAddr, backlog, AcceptedItems, sessionCreator))); }

また素晴らしいではありません。両方のクラスは

リスニングストリーム

 class ListenThread : private TCPServerSocket , public Common::IDisposable { public: ListenThread(InetAddress const &locAddr, int backlog, ClientItemQueuePtr acceptedClients, UserSessionCreator sessionCreator) : TCPServerSocket(locAddr, backlog) , AcceptedClients(acceptedClients) , SessionCreator(sessionCreator) , Selector(1, WaitTimeout, std::tr1::bind(&ListenThread::OnSelect, this, std::tr1::placeholders::_1, std::tr1::placeholders::_2)) { Selector.AddSocket(GetHandle(), Network::ISelector::stRead); } private: enum { WaitTimeout = 100 }; ClientItemQueuePtr AcceptedClients; UserSessionCreator SessionCreator; SelectorThread Selector; void OnSelect(SocketHandle handle, Network::ISelector::SelectType selectType) { //  ,  -      } };

だから

ワークフロー

 class WorkerThread : private Common::NonCopyable , public Common::IDisposable { public: WorkerThread(int maxEventsCount, ClientItemQueuePtr acceptedClients) : MaxConnections(maxEventsCount) , AcceptedClients(acceptedClients) , Selector(maxEventsCount, WaitTimeout, std::tr1::bind(&WorkerThread::OnSelect, this, std::tr1::placeholders::_1, std::tr1::placeholders::_2), SelectorThread::ThreadFunctionPtr(new SelectorThread::ThreadFunction(std::tr1::bind( &WorkerThread::OnIdle, this)))) { } private: enum { WaitTimeout = 100 }; typedef std::map<SocketHandle, ClientItemPtr> ClientPool; unsigned MaxConnections; ClientItemQueuePtr AcceptedClients; ClientPool Clients; SelectorThread Selector; void OnSelect(SocketHandle handle, Network::ISelector::SelectType selectType) { //  ,      ( ,  ,  ) } void OnIdle() { //   .         -  epoll. } };

イベントフロークラスを使用する

セレクタースレッド

 class SelectorThread : private EPollSelector , private System::ThreadLoop { public: using EPollSelector::AddSocket; typedef System::Thread::ThreadFunction ThreadFunction; typedef std::tr1::shared_ptr<ThreadFunction> ThreadFunctionPtr; SelectorThread(int maxEventsCount, unsigned waitTimeout, ISelector::SelectFunction onSelectFunc, ThreadFunctionPtr idleFunc = ThreadFunctionPtr()); virtual ~SelectorThread(); private: void SelectItems(ISelector::SelectFunction &func, unsigned waitTimeout, ThreadFunctionPtr idleFunc); };

。このスレッドは

EPollSelector

 class EPollSelector : private Common::NonCopyable , public ISelector { public: EPollSelector(int maxSocketCount); ~EPollSelector(); virtual void AddSocket(SocketHandle handle, int selectType); virtual void Select(SelectFunction *function, unsigned timeout); private: typedef std::vector<epoll_event> EventPool; EventPool Events; int EPoll; static int GetSelectFlags(int selectType); };

承認された化合物の記述子で発生するイベントに対する反応を整理するため。
サーバーのソースクラスを見ると、ユーザーセッションクラスを作成するためのファンクターが最後のパラメーターとして渡されていることがわかります。ユーザーセッションはインターフェースの実装です

 struct IUserSession { virtual ~IUserSession() {} virtual void Init(IConnectionCtrl *ctrl) = 0; virtual void Done() = 0; virtual unsigned GetMaxBufSizeForRead() const = 0; virtual bool IsExpiredSession(std::time_t lastActionTime) const = 0; virtual void OnRecvData(void const *buf, unsigned bytes) = 0; virtual void OnIdle() = 0; };

このインターフェイスの実装に応じて、異なるプロトコルを実装できます。 InitメソッドとDoneメソッドは、それぞれセッションの開始時と終了時に呼び出されます。 GetMaxBufSizeForReadは、データ読み取り操作中に割り当てられる最大バッファーサイズを返す必要があります。読み取られたデータはOnRecvDataに含まれます。セッションが期限切れになったことを伝えるには、IsExpiredSessionを適切な方法で実装する必要があります。 OnIdleはいくつかのアクションの間に呼び出されます。ここで、セッション実装はいくつかのバックグラウンドアクションを実行し、インターフェイスを介して閉じることを目的として自身をマークできます。

 struct IConnectionCtrl { virtual ~IConnectionCtrl() { } virtual void MarkMeForClose() = 0; virtual void UpdateSessionTime() = 0; virtual bool SendData(void const *buf, unsigned *bytes) = 0; virtual bool SendFile(int fileHandle, unsigned offset, unsigned *bytes) = 0; virtual InetAddress const& GetAddress() const = 0; virtual SocketTuner GetSocketTuner() const = 0; };

IConnectionCtrlインターフェイスは、ユーザーセッションがネットワークにデータを送信できるように（SendDataおよびSendFileメソッド）、閉じられるように自身をマークできるように（MarkMeForCloseメソッド）、「生きている」（UpdateSessionTimeメソッド。 IsExpiredSession）、同じセッションは着信接続（GetAddressメソッド）のアドレスとソケット設定のSocketTunerオブジェクト（現在の接続（GetSocketTunerメソッド））を取得できます。
HTTPプロトコルの実装は、HttpUserSessionクラスにあります。上で言ったように、HTTPの実装は私にとって最も興味深くも優先度も低いので、あまり考えませんでした。私は何が起こったのかを書くのに十分であると正確に思った:)

Libeventの実装

libeventでの実装は今でも私にとってお気に入りです。このライブラリにより、非同期入出力を整理し、ネットワークプログラミングの微妙な点の多くを開発者から隠すことができます。これにより、データやその他のイベントの受信、送信、データの非同期送信のためのコールバック関数をハングアップすることにより、生データの処理を実装できます。データの低レベルの作業に加えて、高レベルのプロトコルもあります。 libeventにはHTTPサーバーが組み込まれているため、要求ヘッダーの解析と同じ応答ヘッダーの生成を抽象化できます。ライブラリおよびその他の機能を使用してRPCを実装することができます。
組み込みを使用してHTTPサーバーを実装する場合、シーケンスは次のようになります。

event_base_newを呼び出して、いくつかの基本的なオブジェクトを作成します（より簡単な場合のために単純化されたevent_initもあります）。オブジェクトを削除するペアの関数はevent_base_freeです。
evhttp_newを呼び出して、HTTPエンジンオブジェクトを作成します。 evhttp_freeオブジェクトを削除するためのペア関数。
フラグの組み合わせでevhttp_set_allowed_methods関数を使用して、サーバーがサポートするメソッドを指定できます。したがって、たとえば、GETメソッドのみをサポートするには、evhttp_set_allowed_methods（Http、EVHTTP_REQ_GET）のようになります。ここで、Httpはステップ（2）で作成された記述子です。
evhttp_set_gencbを呼び出して、着信要求を処理するコールバック関数を設定します。
evhttp_accept_socket関数を呼び出して、リスニングソケットをHTTPサーバーオブジェクトのインスタンスに関連付けます。リスニングソケットは、同じソケット/バインド/リスンを介して作成および構成できます。
event_base_loop関数を呼び出して、イベントループを開始します。 event_base_dispatchという簡単なオプションがあります。 event_base_loopはループで呼び出す必要があります。この関数は、インストールされたコールバック関数への呼び出しが行われるライブラリの腸内で何か有用なことを行うか、何もする必要がない場合に制御を返し、この時点で何か便利なことができます。また、メッセージ処理サイクルの寿命をより簡単に制御することも可能になります。
リクエストハンドラでは、evbuffer_add_printfを呼び出してテキストデータを送信するか、ライブラリにファイル記述子を指定して、evbuffer_add_fileを呼び出して送信することができます。これらの関数は、自分で作成する（時間内に削除することを忘れないでください）か、要求フィールドevhttp_request :: output_bufferを使用できるバッファーオブジェクトで動作します。すべての魅力は、これらの関数が非同期であるということです。ファイルを送信する例では、ファイル記述子を同じevbuffer_add_fileに渡すと、すぐに制御が返され、ファイルが送信された後、ファイル自体が閉じられます。

すべてが1つのスレッドで非常に美しくなりますが、判明したように、マルチスレッドサーバーを作成することも難しくありません。 boost ::スレッド、またはストリームの作業をカプセル化するクロスプラットフォームクラスなどを使用すると、libeventはクロスプラットフォームライブラリであるため、完全にクロスプラットフォームのソリューションを取得できます。私自身の実装では、Linuxのストリームに対してのみラッパーを使用します。しかし、これはそれほど重要ではありません。
各ワークフローのメインスレッドは、独自の記述子を作成する必要があります。手順1〜5を完了します。ワークフローは、メッセージ処理サイクルのみをねじる必要があります-ステップ6。各ワークフローでステップ7が実行されます。要約すると、1つのリスニングソケットを作成し、その処理を複数のワーカースレッドに課します。
そのため、実装では、ストリーム、ファイル、およびコマンドライン解析用のプリミティブが既にいくつかあるため、C＃/ Javaスタイルで約200行のGETメソッドのみをサポートするHTTPサーバーを取得しました。起こっていることを完全に制御してコードを記述する作業のこの削減は、喜ばしいことです。さらに、主観的に、結果のサーバーは少し速く動作しますが、最後にテストを見てみましょう...

libeventでのHTTPサーバーの実装

 #include <event.h> #include <evhttp.h> #include <unistd.h> #include <string.h> #include <signal.h> #include <vector> #include <iostream> #include <tr1/functional> #include <tr1/memory> #include "tcp_server_socket.h" #include "inet_address_v4.h" #include "thread.h" #include "command_line.h" #include "logger.h" #include "file_holder.h" namespace Network { namespace Private { DECLARE_RUNTIME_EXCEPTION(EventBaseHolder) class EventBaseHolder : private Common::NonCopyable { public: EventBaseHolder() : EventBase(event_base_new()) { if (!EventBase) throw EventBaseHolderException("Failed to create new event_base"); } ~EventBaseHolder() { event_base_free(EventBase); } event_base* GetBase() const { return EventBase; } private: event_base *EventBase; }; DECLARE_RUNTIME_EXCEPTION(HttpEventHolder) class HttpEventHolder : public EventBaseHolder { public: typedef std::tr1::function<void (char const *, evbuffer *)> RequestHandler; HttpEventHolder(SocketHandle sock, RequestHandler const &handler) : Handler(handler) , Http(evhttp_new(GetBase())) { evhttp_set_allowed_methods(Http, EVHTTP_REQ_GET); evhttp_set_gencb(Http, &HttpEventHolder::RawHttpRequestHandler, this); if (evhttp_accept_socket(Http, sock) == -1) throw HttpEventHolderException("Failed to accept socket for http"); } ~HttpEventHolder() { evhttp_free(Http); } private: RequestHandler Handler; evhttp *Http; static void RawHttpRequestHandler(evhttp_request *request, void *prm) { reinterpret_cast<HttpEventHolder *>(prm)->ProcessRequest(request); } void ProcessRequest(evhttp_request *request) { try { Handler(request->uri, request->output_buffer); evhttp_send_reply(request, HTTP_OK, "OK", request->output_buffer); } catch (std::exception const &e) { evhttp_send_reply(request, HTTP_INTERNAL, e.what() ? e.what() : "Internal server error.", request->output_buffer); } } }; class ServerThread : private HttpEventHolder , private System::Thread { public: ServerThread(SocketHandle sock, std::string const &rootDir, std::string const &defaultPage) : HttpEventHolder(sock, std::tr1::bind(&ServerThread::OnRequest, this, std::tr1::placeholders::_1, std::tr1::placeholders::_2)) , Thread(std::tr1::bind(&ServerThread::DispatchProc, this)) , RootDir(rootDir) , DefaultPage(defaultPage) { } ~ServerThread() { IsRun = false; } private: enum { WaitTimeout = 10000 }; bool volatile IsRun; std::string RootDir; std::string DefaultPage; void DispatchProc() { IsRun = true; while(IsRun) { if (event_base_loop(GetBase(), EVLOOP_NONBLOCK)) { Common::Log::GetLogInst() << "Failed to run dispatch events"; break; } usleep(WaitTimeout); } } void OnRequest(char const *resource, evbuffer *outBuffer) { std::string FileName; GetFullFileName(resource, &FileName); try { System::FileHolder File(FileName); if (!File.GetSize()) { evbuffer_add_printf(outBuffer, "Empty file"); return; } evbuffer_add_file(outBuffer, File.GetHandle(), 0, File.GetSize()); File.Detach(); } catch (System::FileHolderException const &) { evbuffer_add_printf(outBuffer, "File not found"); } } void GetFullFileName(char const *resource, std::string *fileName) const { fileName->append(RootDir); if (!resource || !strcmp(resource, "/")) { fileName->append("/"); fileName->append(DefaultPage); } else { fileName->append(resource); } } }; } class HTTPServer : private TCPServerSocket { public: HTTPServer(InetAddress const &locAddr, int backlog, int maxThreadsCount, std::string const &rootDir, std::string const &defaultPage) : TCPServerSocket(locAddr, backlog) { for (int i = 0 ; i < maxThreadsCount ; ++i) { ServerThreads.push_back(ServerThreadPtr(new Private::ServerThread(GetHandle(), rootDir, defaultPage))); } } private: typedef std::tr1::shared_ptr<Private::ServerThread> ServerThreadPtr; typedef std::vector<ServerThreadPtr> ServerThreadPool; ServerThreadPool ServerThreads; }; } int main(int argc, char const **argv) { if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { std::cerr << "Failed to call signal(SIGPIPE, SIG_IGN)" << std::endl; return 0; } try { char const ServerAddr[] = "Server"; char const ServerPort[] = "Port"; char const MaxBacklog[] = "Backlog"; char const ThreadsCount[] = "Threads"; char const RootDir[] = "Root"; char const DefaultPage[] = "DefaultPage"; // Server:127.0.0.1 Port:5555 Backlog:10 Threads:4 Root:./ DefaultPage:index.html Common::CommandLine CmdLine(argc, argv); Network::HTTPServer Srv( Network::InetAddressV4::CreateFromString( CmdLine.GetStrParameter(ServerAddr), CmdLine.GetParameter<unsigned short>(ServerPort)), CmdLine.GetParameter<unsigned>(MaxBacklog), CmdLine.GetParameter<unsigned>(ThreadsCount), CmdLine.GetStrParameter(RootDir), CmdLine.GetStrParameter(DefaultPage) ); std::cin.get(); } catch (std::exception const &e) { Common::Log::GetLogInst() << e.what(); } return 0; }

boost.asioでの実装

boost.asioはboostの一部であり、ネットワークアプリケーション、およびクロスプラットフォームアプリケーションの開発を大幅に削減するのに役立ちます。ライブラリは、開発者から多くのルーチンを隠します。
ブーストでHTTPサーバーの実装を作成しませんでした。完成した例をboost.asioに取りました。 マルチスレッドHTTPサーバーの例。 HTTPサーバー3この例の実装は、上記の例と組み合わせたテストに非常に適しています。
テスト用のHTTPサーバーの実装がありますが、一般的な原則について話すのは悪くありません...残念ながら、libeventとは異なり、boost.asioはHTTPなどに類似した高レベルのプロトコルをサポートしていません。この場合、ライブラリはTCPを介したネットワークでの作業を隠しますが、プロトコルヘッダーを収集および解析するには、HTTPの実装を開発者自身が行う必要があります。
以下は、このトピックに照らしてHTTPヘッダーを解析/収集するのはあまり面白くないので、説明付きのマルチスレッドエコーサーバーの小さな例です。 boost.asioを使用してマルチスレッドサーバーを作成する手順は次のとおりです。

boost :: asio :: io_serviceおよびboost :: asio :: ip :: tcp ::アクセプタークラスのオブジェクトを作成します。
boost :: asio :: ip :: tcp :: resolverおよびboost :: asio :: ip :: tcp ::エンドポイントを使用すると、リスニングソケットがバインドされるローカルアドレスがライブラリで使用される構造に変換されます。
bindを呼び出して、クラスboost :: asio :: ip :: tcp :: acceptorのオブジェクトでリッスンします。
クラス「接続」を作成します。別名「セッション」。着信ユーザー接続を受信するときにそのインスタンスが使用されます。
適切なコールバック関数を構成して、着信接続を受信し、データを受信します。
boost :: asio :: io_service :: runを呼び出して、メッセージ処理ループを開始します。

また、libeventの例と同様に、マルチスレッドサーバーは、上記の一連の手順を使用してシングルスレッドサーバーから非常に簡単に作成できます。この場合、シングルスレッドサーバーとマルチスレッドサーバーの違いは、マルチスレッド実装の各スレッドでboost :: asio :: io_service :: runメソッドを呼び出す必要があることだけです。

boost.asioでのエコーサーバーの実装

 #include <boost/noncopyable.hpp> #include <boost/asio.hpp> #include <boost/shared_ptr.hpp> #include <boost/thread.hpp> #include <boost/make_shared.hpp> #include <boost/bind.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/array.hpp> namespace Network { namespace Private { class Connection : private boost::noncopyable , public boost::enable_shared_from_this<Connection> { public: Connection(boost::asio::io_service &ioService) : Strand(ioService) , Socket(ioService) { } boost::asio::ip::tcp::socket& GetSocket() { return Socket; } void Start() { Socket.async_read_some(boost::asio::buffer(Buffer), Strand.wrap( boost::bind(&Connection::HandleRead, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred) )); } void HandleRead(boost::system::error_code const &error, std::size_t bytes) { if (error) return; std::vector<boost::asio::const_buffer> Buffers; Buffers.push_back(boost::asio::const_buffer(Buffer.data(), bytes)); boost::asio::async_write(Socket, Buffers, Strand.wrap( boost::bind(&Connection::HandleWrite, shared_from_this(), boost::asio::placeholders::error) )); } void HandleWrite(boost::system::error_code const &error) { if (error) return; boost::system::error_code Code; Socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, Code); } private: boost::array<char, 4096> Buffer; boost::asio::io_service::strand Strand; boost::asio::ip::tcp::socket Socket; }; } class EchoServer : private boost::noncopyable { public: EchoServer(std::string const& locAddr, std::string const& port, unsigned threadsCount) : Acceptor(IoService) , Threads(threadsCount) { boost::asio::ip::tcp::resolver Resolver(IoService); boost::asio::ip::tcp::resolver::query Query(locAddr, port); boost::asio::ip::tcp::endpoint Endpoint = *Resolver.resolve(Query); Acceptor.open(Endpoint.protocol()); Acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); Acceptor.bind(Endpoint); Acceptor.listen(); StartAccept(); std::generate(Threads.begin(), Threads.end(), boost::bind( &boost::make_shared<boost::thread, boost::function<void ()> const &>, boost::function<void ()>(boost::bind(&boost::asio::io_service::run, &IoService)) )); } ~EchoServer() { std::for_each(Threads.begin(), Threads.end(), boost::bind(&boost::asio::io_service::stop, &IoService)); std::for_each(Threads.begin(), Threads.end(), boost::bind(&boost::thread::join, _1)); } private: boost::asio::io_service IoService; boost::asio::ip::tcp::acceptor Acceptor; typedef boost::shared_ptr<Private::Connection> ConnectionPtr; ConnectionPtr NewConnection; typedef boost::shared_ptr<boost::thread> ThreadPtr; typedef std::vector<ThreadPtr> ThreadPool; ThreadPool Threads; void StartAccept() { NewConnection = boost::make_shared<Private::Connection, boost::asio::io_service &>(IoService); Acceptor.async_accept(NewConnection->GetSocket(), boost::bind(&EchoServer::HandleAccept, this, boost::asio::placeholders::error)); } void HandleAccept(boost::system::error_code const &error) { if (!error) NewConnection->Start(); StartAccept(); } }; } int main() { try { Network::EchoServer Srv("127.0.0.1", "5555", 4); std::cin.get(); } catch (std::exception const &e) { std::cerr << e.what() << std::endl; } return 0; }

テスト中

受け取った工芸品を比較する時が来ました...
すべてが開発およびテストされたプラットフォームは、4GBのRAMとUbuntu 12.04デスクトップを実行する2コアプロセッサを搭載した通常のラップトップです。
まず、テスト用のユーティリティを配置します。

 sudo apt-get install apache2-utils

この方法でテストします：

 ab -c 100 -k -r -t 5 "http://127.0.0.1:5555/test.jpg"

すべてのサーバーについて、4つのワークフロー、100の並列接続、2496629バイトの送信用ファイル、および5秒の推定時間間隔が設定されました。
結果：

Epollの実装

ベンチマーク127.0.0.1（忍耐強く）
完了した2150リクエスト

サーバーソフトウェア：MyTestHttpServer
サーバーのホスト名：127.0.0.1
サーバーポート：5555

ドキュメントパス：/test.jpg
ドキュメントの長さ：2496629バイト

同時実行レベル：100
テストにかかった時間：5.017秒
完全なリクエスト：2150
失敗したリクエスト：0
書き込みエラー：0
キープアライブ要求：0
転送された合計：5389312814バイト
転送されるHTML：5388981758バイト
1秒あたりのリクエスト：428.54 [＃/ sec]（平均）
リクエストあたりの時間：233.348 [ms]（平均）
リクエストあたりの時間：2.333 [ms]（平均、すべての同時リクエスト全体）
転送速度：1049037.42 [キロバイト/秒]受信

接続時間（ミリ秒）
最小平均[±sd]最大中央値
接続：0 0 0.5 0 3
処理：74226 58.2 229 364
待機中：2 133 64.8 141 264
合計：77226 58.1 229 364

Libeventの実装

ベンチマーク127.0.0.1（忍耐強く）
完了した1653リクエスト

サーバーソフトウェア：
サーバーのホスト名：127.0.0.1
サーバーポート：5555

ドキュメントパス：/test.jpg
ドキュメントの長さ：2496629バイト

同時実行レベル：100
テストにかかった時間：5.008秒
完全なリクエスト：1653
失敗したリクエスト：0
書き込みエラー：0
キープアライブリクエスト：1653
転送された合計：4263404830バイト
転送されるHTML：4263207306バイト
1秒あたりのリクエスト：330.05 [＃/秒]（平均）
リクエストあたりの時間：302.987 [ms]（平均）
リクエストあたりの時間：3.030 [ms]（平均、すべての同時リクエスト全体）
転送速度：831304.15 [キロバイト/秒]受信

接続時間（ミリ秒）
最小平均[±sd]最大中央値
接続：0 53 223.3 0 1000
処理：3 228 275.5 62 904
待機中：0 11 42.5 5 639
合計：3 280 417.9 62 1864

boost.asioでの実装

ベンチマーク127.0.0.1（忍耐強く）
終了した639リクエスト

サーバーソフトウェア：
サーバーのホスト名：127.0.0.1
サーバーポート：5555

ドキュメントパス：/test.jpg
ドキュメントの長さ：2496629バイト

同時実行レベル：100
テストにかかった時間：5.001秒
完全なリクエスト：639
失敗したリクエスト：0
書き込みエラー：0
キープアライブ要求：0
転送された合計：1655047414バイト
転送されるHTML：1654999464バイト
1秒あたりのリクエスト：127.78 [＃/ sec]（平均）
リクエストあたりの時間：782.584 [ms]（平均）
リクエストあたりの時間：7.826 [ms]（平均、すべての同時リクエスト全体）
転送速度：323205.36 [Kバイト/秒]受信

接続時間（ミリ秒）
最小平均[±sd]最大中央値
接続：0 0 1.1 0 4
処理：286 724 120.0 689 1106
待機中：12 364 101.0 394 532
合計：286724 120.0 689 1106

結果は表にまとめられています。

	エポール	libevent	boost.asio
完全なリクエスト	2150	1653	639
転送された合計（バイト）	5389312814	4263404830	1655047414
転送されたHTML（バイト）	5388981758	4263207306	1654999464
1秒あたりのリクエスト[秒]（平均）	428.54	330.05	127.78
リクエストあたりの時間[ms]（平均）	233.348	302.987	782.584
受信した転送速度[キロバイト/秒]	1049037.42	831304.15	323205.36

嘘には、嘘、露骨な嘘、統計の3種類があります。認めざるを得ないが、結果は私を喜ばせざるを得ない。結果に特別な注意を払うべきではないと思いますが、サーバーソフトウェア用の開発ツールの選択を決定する際に役立つかもしれないサポート情報としてそれらを見ることができます。結果を正確にするために、サーバーハードウェア上で複数の実行、ネットワーク上の他のマシンで実行中のクライアントなどを配置することをお勧めします。
100並列クエリ-これは小さいように見えますが、そのような控えめな条件でテストするには十分です。もちろん、何千もの並列クエリの結果を確認したいのですが、すでに他の要因があります。そのような要因の1つは、プロセスで同時に開くことができるファイル記述子の数です。 getrlimitおよびsetrlimit関数を呼び出すことにより、いくつかのプロセスパラメータを見つけて設定できます。プロセスごとに割り当てられているファイル記述子の数を調べるには、rlimit構造体のフラグRLIMIT_NOFILEを指定してgetrlimitを呼び出すことができます。オペレーティングシステムの場合、これらはデフォルトでプロセスごとに1024個のファイル記述子であり、プロセスに設定できる最大4096個です。 … , , . Linux

WebServer «» , , . . , - , - , - - . , epoll . , , . « », , , C++, C, stl, .
, libevent, , , , . .
, boost . . boost.asio . «» , , .
Linux (aio) , «» .

SVN . , . しかし！ , . « » , , — , — , — . :)

«» API .

ご清聴ありがとうございました！