การดาวน์โหลด stream client - การดาวน์โหลดซอร์สโค้ด stream client

สตรีม-ลูกค้า

นี่คือห้องสมุดที่มีน้ำหนักเบาเพียงส่วนหัวเท่านั้นที่ใช้ห้องสมุดที่ใช้ Boost โดยให้บริการเครือข่ายฝั่งไคลเอ็นต์เพื่อจัดระเบียบและใช้การส่งข้อมูลด้วยจุดสิ้นสุดระยะไกลได้อย่างง่ายดาย

ห้องสมุดนี้:

แรงบันดาลใจจากและสร้างรอบ boost.asio
จัดเตรียมโครงสร้างระดับสูงเป็นตัวเชื่อมต่อและกลุ่มการเชื่อมต่อ
รองรับโปรโตคอล TCP / UDP / SSL / HTTP / HTTPS
ใช้ซ็อกเก็ตที่มีอินเทอร์เฟซเดียวกันกับ Boost :: ASIO :: IP
อนุญาตให้ควบคุมการหมดเวลา/กำหนดเวลาที่โปร่งใสสำหรับการดำเนินการทั้งหมด
ต้องใช้ BOOST 1.65+ หรือ 1.66+ หากคุณวางแผนที่จะใช้โปรโตคอล HTTP

ทำไม

หากคุณกำลังเขียนซอฟต์แวร์บน C ++ ซึ่งสื่อสารกับบริการอื่น ๆ ในฐานะไคลเอนต์คุณอาจมาพร้อมกับปัญหา - จำเป็นต้องใช้เลเยอร์การเชื่อมต่อเพื่อให้การขนส่งเครือข่ายไปยังบริการที่เกี่ยวข้องทั้งหมด นี่คือสิ่งที่ห้องสมุดนี้มีจุดประสงค์เพื่อแก้ไข

วิธีใช้

ซ็อกเก็ต

ซ็อกเก็ตถูกนำไปใช้ที่ด้านบนของ boost::asio::basic_socket และให้ชั้นเรียนที่มีการควบคุมการหมดเวลาดังนั้นในกรณีส่วนใหญ่ก็เพียงพอที่จะโทร ส่ง () / รับ () / write_some () / read_some () ด้วยกำหนดเวลาหรือหมดเวลา ข้อมูลที่ให้กับการดำเนินการ I/O ควรถูกห่อหุ้มลงใน boost::asio::buffer โดยพื้นฐานแล้วลูกค้าเหล่านี้เป็น boost::asio::ip และมีอินเทอร์เฟซเดียวกัน

คลาสสตรีมไคลเอนต์:

stream_client::tcp_client - ไคลเอ็นต์ซ็อกเก็ตสตรีม TCP ธรรมดา รองรับ send () / rececive () สำหรับการถ่ายโอนบัฟเฟอร์ทั้งหมดพร้อมกับ write_some () / read_some () เพื่อถ่ายโอนอย่างน้อยบางอย่าง
stream_client::udp_client - ไคลเอ็นต์ซ็อกเก็ต UDP ธรรมดา รองรับเฉพาะ SEND () / รับ () โดยไม่ต้องรับทราบตามข้อมูลจำเพาะ UDP
stream_client::ssl::ssl_client - ไคลเอนต์ TCP ที่เข้ารหัส SSL มีฟังก์ชั่นเดียวกันกับการจับมือกัน tcp_client Plus SSL และการควบคุมบริบท
stream_client::http::http_client - ไคลเอนต์ http ห่อ tcp_client ด้วย boost::beast::http::parser และ boost::beast::http::serializer และมี ฟังก์ชั่น () ฟังก์ชั่นเพื่อทำการตอบสนองการร้องขอ
stream_client::http::https_client - ไคลเอนต์ https เหมือนกับ http_client แต่ใช้ไคลเอนต์ ssl_client ใต้

ตัวอย่าง

 const boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address::from_string( " 127.0.0.1 " ), 12345);
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );

// this makes connected socket and may take up to connect_timeout time
stream_client::tcp_client client (endpoint, connect_timeout, io_timeout);

// send() operation will transmit all contents of send_data or throw an error;
// also it will throw boost::asio::error::timed_out after io_timeout.
const std::string send_data = " test data " ;
client.send(boost::asio::buffer(send_data.data(), send_data.size()));

// receive() operation will read send_data.size() size or throw an error;
// also it will throw boost::asio::error::timed_out after io_timeout.
std::string recv_data (send_data.size(), '');
client.receive(boost::asio::buffer(&recv_data[ 0 ], send_data.size()));

// there are also non-throw overloads to these functions which
// will set boost::system::error_code instead of exception;

DNS Resolver

Resolver ถูกนำไปใช้กับแนวคิดเดียวกัน - ทำการซิงค์, ตัวแก้ไข DNS ที่กำหนดเวลาดังนั้นจึงใช้ boost::asio::ip::basic_resolver เพื่อดำเนินการแก้ไขจริงภายในหมดเวลาที่ระบุ

มันเป็นเทมเพลตคลาสที่มีพารามิเตอร์เดียว - โปรโตคอลผลลัพธ์และคุณสามารถระบุประเภทของจุดสิ้นสุด IP ที่คุณสนใจ - IPv4, IPv6 หรือทั้งสองอย่าง ความละเอียดที่ดำเนินการด้วยการโทร RESORVE () ซึ่งมีลายเซ็นที่คล้ายกันกับการดำเนินการของซ็อกเก็ต - คุณมีอิสระที่จะระบุการหมดเวลา/กำหนดเวลาหรือใช้ค่าเริ่มต้น

คลาส Resolver:

stream_client::resolver::tcp_resolver - ตัวแก้ไขซึ่งส่งคืนตัววนซ้ำของจุดสิ้นสุด TCP
stream_client::resolver::udp_resolver - ตัวแก้ไขซึ่งส่งคืนตัววนซ้ำของจุดสิ้นสุด UDP

ตัวอย่าง

 const std::chrono::milliseconds resolve_timeout ( 5000 );

stream_client::resolver::tcp_resolver resolver ( " localhost " , " 12345 " ,
                                               resolve_timeout,
                                               stream_client::resolver::ip_family::ipv4);

// resolve() guaranteed to return at least one endpoint or will throw an error;
// it will throw boost::asio::error::timed_out after resolve_timeout.
auto endpoints_it = resolver.resolve();

// returned iterator is an instance of boost::asio::ip::basic_resolver::iterator<Protocol>

ตัวเชื่อมต่อ

ตัวเชื่อมต่อใช้ Resolver เพื่อดำเนินการ DNS ความละเอียดและอัปเดตรายการจุดสิ้นสุดและใช้หากร้องขอด้วย new_session () เพื่อสร้างซ็อกเก็ตใหม่ของโปรโตคอลที่ระบุ งานของ DNS Resolver ถูกห่อหุ้มด้วยเธรดพื้นหลังซึ่งก่อให้เกิดการสร้างหรือหากมีข้อผิดพลาดในการเปิดซ็อกเก็ตใหม่

จุดสิ้นสุดเป้าหมายเพื่อเปิดซ็อกเก็ตใหม่ที่เลือกแบบสุ่มจากผลลัพธ์ DNS ซึ่งทำให้ ตัวเชื่อมต่อที่สมดุล กับโฮสต์ระยะไกล นอกจากนี้ตัวเชื่อมต่ออนุญาตให้ระบุการหมดเวลาแยกต่างหากสำหรับความละเอียดการเชื่อมต่อและการทำงาน I/O ของซ็อกเก็ตใหม่

คลาสเชื่อมต่อ:

stream_client::connector::tcp_connector - ตัวเชื่อมต่อ TCP, เพื่อรับ stream_client::tcp_client
stream_client::connector::udp_connector - ตัวเชื่อมต่อ UDP, เพื่อรับ stream_client::udp_client SOCKETS
stream_client::connector::ssl_connector - ตัวเชื่อมต่อ TCP เพื่อรับ stream_client::ssl::ssl_client Sockets
stream_client::connector::http_connector - ตัวเชื่อมต่อ http เพื่อรับ stream_client::http::http_client sockets
stream_client::connector::https_connector - ตัวเชื่อมต่อ HTTPS เพื่อรับ stream_client::http::https_client sockets

ตัวอย่าง

 const std::chrono::milliseconds resolve_timeout ( 5000 );
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );

// this will return immediately, starting background thread for name resolution
stream_client::connector::tcp_connector connector ( " localhost " , " 12345 " ,
                                                  resolve_timeout, connect_timeout, io_timeout,
                                                  stream_client::resolver::ip_family::ipv4);

// this will acquire new socket or throw;
// it will throw boost::asio::error::timed_out after connect_timeout
std::unique_ptr<stream_client::tcp_client> client = connector.new_session();

// use the client
const std::string send_data = " test data " ;
std::string recv_data (send_data.size(), '');
client-> send (boost::asio::buffer(send_data.data(), send_data.size()));
client-> receive (boost::asio::buffer(&recv_data[ 0 ], send_data.size()));

กลุ่มการเชื่อมต่อ

แสดงถึงภาชนะที่ครอบครองด้วยซ็อกเก็ตที่เปิดอยู่ ใช้ตัวเชื่อมต่อเพื่อเปิดซ็อกเก็ตใหม่ในเธรดพื้นหลังซึ่งถูกกระตุ้นเมื่อมีสถานที่ว่างในสระว่ายน้ำ ผู้ใช้สามารถโทรหา get_session () เพื่อรับซ็อกเก็ตจากพูลและ return_session () เพื่อให้คืน

มีสองกลยุทธ์ในการเติมสระว่ายน้ำ:

Greedy ( stream_client::connector::greedy_strategy ) หากมีสถานที่ว่างมันจะพยายามเติมเต็มด้วยเซสชันใหม่พร้อมกัน นี่คือค่าเริ่มต้น
อนุรักษ์นิยม ( stream_client::connector::conservative_strategy ) จะพยายามเติมเต็มสถานที่ว่างมากถึง 2/3 ในแบบสำรวจ หากล้มเหลวจะกลับมาสักพักแล้วลองอีกครั้งในภายหลัง นอกจากนี้หลังจากความล้มเหลวมันจะสร้างเซสชันใหม่เพียงครั้งเดียว

ทั้งคู่ถูกกำหนดไว้ในแง่ของ stream_client::connector::pool_strategy ดังนั้นคุณจึงมีอิสระที่จะใช้งานใหม่

ข้อ จำกัด :

ซ็อกเก็ตที่อยู่ในสระว่ายน้ำนั้นไม่ได้ถูกตรวจสอบหรือดูแลรักษาในทางใดทางหนึ่ง ดังนั้นสระว่ายน้ำไม่รับประกันว่าซ็อกเก็ตทั้งหมดจะถูกเปิดในเวลาตามอำเภอใจเนื่องจากความซับซ้อนของการตรวจสอบดังกล่าวสำหรับโปรโตคอลที่รองรับทั้งหมด
ไม่มีอะไรเฉพาะกับซ็อกเก็ตเมื่อกลับมาภายใน return_session () ดังนั้นหากพวกเขามีหรือจะมีข้อมูลที่รอการอ่านมันจะอยู่ที่นั่นจนกว่าจะอ่าน

เมื่อพิจารณาถึงสิ่งนี้กลยุทธ์ที่ดีที่สุดในการใช้กลุ่มการเชื่อมต่อนั้นเป็นเช่นนั้น:

สร้างมันโดยระบุการหมดเวลาทั้งหมดตามที่คุณต้องการ
เมื่อสร้างขึ้นแล้วให้ใช้ get_session () เพื่อรับซ็อกเก็ตที่เปิด
จำเป็นต้องมีการดำเนินการ I/O บนซ็อกเก็ต
หาก 2-3 สำเร็จให้ส่งคืนกลับด้วย return_session () อื่น ๆ ทำซ้ำจุด 2

มันเป็นสิ่งสำคัญที่จะทิ้งซ็อกเก็ตเกี่ยวกับความล้มเหลวและไม่นำกลับมาใช้ใหม่หรือการจัดการการตอบสนองต่อการร้องขอจะน่ารังเกียจ

กลุ่มเชื่อมต่อ:

stream_client::connector::tcp_pool - Pool of stream_client::tcp_client
stream_client::connector::udp_pool - Pool of stream_client::udp_client Sockets
stream_client::connector::ssl_pool - พูลของ stream_client::ssl::ssl_client Sockets
stream_client::connector::http_pool - พูลของ stream_client::http::http_client sockets
stream_client::connector::https_pool - Pool of stream_client::http::https_client sockets

นอกจากนี้ยังมีนามแฝงสำหรับกลุ่มเดียวกัน แต่ใช้กลยุทธ์การเชื่อมต่อแบบอนุรักษ์นิยม:

stream_client::connector::tcp_conservative_pool
stream_client::connector::udp_conservative_pool
stream_client::connector::ssl_conservative_pool
stream_client::connector::http_conservative_pool
stream_client::connector::https_conservative_pool

ตัวอย่าง

 const std::chrono::milliseconds resolve_timeout ( 5000 );
const std::chrono::milliseconds connect_timeout ( 1000 );
const std::chrono::milliseconds io_timeout ( 100 );

auto connector_pool =
    std::make_shared<stream_client::connector::tcp_pool>( " localhost " , " 12345 " ,
                                                         resolve_timeout, connect_timeout, io_timeout,
                                                         stream_client::resolver::ip_family::ipv4);
const size_t threads_num = 10 ;
std::vector<std::thread> threads;
const std::string send_data = " test data " ;
std::mutex stdout_mutex;

for ( size_t i = 0 ; i < threads_num; ++i) {
    threads. emplace_back ([&send_data, &stdout_mutex, connector_pool]() {
        std::string recv_data (send_data. size (), '  ' );

        auto client = connector_pool-> get_session ();
        // both these calls will throw exception on error or timeout
        client-> send ( boost::asio::buffer (send_data. data (), send_data. size ()));
        client-> receive ( boost::asio::buffer (&recv_data[ 0 ], send_data. size ()));
        // if there was no exception, return it
        connector_pool-> return_session ( std::move (client));

        const std::lock_guard<std::mutex> lk (stdout_mutex);
        std::cout << std::this_thread::get_id () << " : " << recv_data << std::endl;
    });
}

for ( auto & t : threads) {
    t. join ();
}

การตัดไม้

ไลบรารีใช้อินเทอร์เฟซ Logger พื้นฐานที่ใช้งานภายใน คุณสามารถแก้ไขระดับ Logger โดยใช้ stream_client::set_log_level() หรือ stream_client::get_log_level() ฟังก์ชั่น

ระดับเหล่านี้ได้รับการสนับสนุน:

 enum class log_level : int
{
    trace = 0 ,
    debug,
    info,
    warning,
    error,
};

โดยเริ่มต้นไลบรารีพิมพ์ข้อความไปยัง stdout ด้วยการจัดรูปแบบที่เหมาะสม หากคุณต้องการเขียนทับพฤติกรรมนี้คุณสามารถตั้งค่าตัวบันทึกของคุณเองผ่าน:

 void stream_client::set_logger (std::shared_ptr<stream_client::log_interface> logger);

void stream_client::set_logger (stream_client::log_level level, stream_client::log_func_type log_func);

ซึ่งช่วยให้สามารถเขียนทับอินสแตนซ์ของ Logger ที่ใช้การโทรกลับด้วยลายเซ็นที่เหมาะสม ประเภทเหล่านี้กำหนดเป็น:

 class log_interface
{
public:
    virtual void set_level (log_level level) noexcept = 0;
    virtual log_level get_level () const noexcept = 0;
    virtual void message (log_level level, const std::string& location, const std::string& message) const = 0;
};

using log_func_type = std::function< void (log_level level, const std::string& location, const std::string& message)>;

สำหรับข้อมูลเพิ่มเติมโปรดดูใน logger.hpp

วิธีการสร้าง

ไลบรารีนี้ควรจะค่อนข้างมีหลายแพลตฟอร์มอย่างไรก็ตามมันถูกทดสอบและใช้เป็นหลักใน Ubuntu และ MacOS
ชอบอาคารนอกแหล่งที่มา

การพึ่งพา Ubuntu

sudo apt update
sudo apt install build-essential cmake libboost-dev libboost-system-dev libssl-dev

การพึ่งพา MacOS

brew install cmake pkg-config icu4c openssl boost

เพื่อสร้าง:

cmake -H. -Bbuild
cmake --build ./build

ในการติดตั้ง (อาจจำเป็นต้องใช้ sudo):

cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=OFF -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build --target install

หรือทดสอบ:

cmake -H. -Bbuild -DSTREAMCLIENT_BUILD_TESTING=ON -DSTREAMCLIENT_BUILD_DOCS=OFF -DSTREAMCLIENT_BUILD_EXAMPLES=OFF
cmake --build ./build
cmake -E chdir ./build ctest --output-on-failure

คำสั่งทั้งหมดเหล่านี้ถือว่าคุณอยู่ในโฟลเดอร์รูทสตรีม-ลูกค้า

ตัวเลือก cmake

cmake_build_type - ประเภทสร้าง RelWithDebInfo โดยค่าเริ่มต้น
build_shared_libs - สร้างห้องสมุดที่ใช้ร่วมกันหรือคงที่ ON โดยค่าเริ่มต้น
StreamClient_build_testing - สร้างการทดสอบหรือไม่ OFF โดยค่าเริ่มต้น
StreamClient_build_examples - สร้างตัวอย่างห้องสมุดหรือไม่ OFF โดยค่าเริ่มต้น
StreamClient_build_docs - สร้างเอกสารอ้างอิง HTML (Sphinx) OFF โดยค่าเริ่มต้น
openssl_use_static_libs - ลิงก์แบบคงที่หรือแบบไดนามิกกับ openssl ที่พบ หาก build_shared_libs OFF ตัวเลือกนี้จะถูกตั้งค่า
OpenSSL_ROOT_DIR - โฟลเดอร์ที่จะมองหา openSSL ตั้งค่าโดย PKG-Config ของ Brew โดยค่าเริ่มต้น

ใบอนุญาต

พัฒนาที่ tinkoff.ru ในปี 2020
แยกแยะภายใต้ใบอนุญาต Apache License 2.0 นอกจากนี้คุณยังสามารถรับใบอนุญาตนี้ได้ที่ https://www.apache.org/licenses/license-2.0