【sylar】框架篇-Chapter14-TcpServer 模块

最新推荐文章于 2024-05-12 21:58:05 发布
最新推荐文章于 2024-05-12 21:58:05 发布
阅读量275 收藏
点赞数
分类专栏： 【C++】服务器编程-实战 文章标签： c++ linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_38647413/article/details/125965059
版权

站在巨人的肩膀上

C++高性能分布式服务器框架

从零开始重写sylar C++高性能分布式服务器框架

概述

  • TCP 服务器的封装。

TcpServerConf

  • TcpServer 配置结构体。
  • 两个模板偏特化：
    • template<> class LexicalCast<std::string, TcpServerConf>
    • template<> class LexicalCast<TcpServerConf, std::string>

TcpServer

  • 继承自 std::enable_shared_from_this 和 sylar::Noncopyable。
  • TcpServer 类支持同时绑定多个地址进行监听，只需要在绑定时传入地址数组即可。有两个重载的 bind 方法。
  • TcpServer 还可以分别指定接收客户端和处理客户端的协程调度器。具体是 m_acceptWorker 和 m_ioWorker。

其他说明

  • TcpServer 类采用了模板模式（Template Pattern）的设计模式，它的 HandleClient 是交由继承类来实现的。使用 TcpServer 时，必须从 TcpServer 派生一个新类，并重新实现子类的 handleClient 操作。
  • 在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

待完善

  • 暂未调试支持 SSL。

部分相关代码

/**
 * @filename    tcp_server.h
 * @brief   Tcp 服务器的封装
 * @author  L-ge
 * @version 0.1
 * @modify  2022-07-13
 */
#ifndef __SYLAR_TCP_SERVER_H__
#define __SYLAR_TCP_SERVER_H__

#include <memory>
#include <functional>
#include "address.h"
#include "iomanager.h"
#include "socket.h"
#include "noncopyable.h"
#include "config.h"

namespace sylar
{

/**
 * @brief   TcpServer配置结构体
 */
struct TcpServerConf
{
    typedef std::shared_ptr<TcpServerConf> ptr;

    std::vector<std::string> address;
    int keepalive = 0;
    int timeout = 1000 * 2 * 60;
    int ssl = 0;
    std::string id;

    // 服务器类型：http、ws、rock
    std::string type = "http";
    std::string name;
    std::string cert_file;
    std::string key_file;
    std::string accept_worker;
    std::string io_worker;
    std::string process_worker;
    std::map<std::string, std::string> args;

    bool isValid() const
    {
        return !address.empty();
    }

    bool operator==(const TcpServerConf& oth) const
    {
        return address == oth.address
            && keepalive == oth.keepalive
            && timeout == oth.timeout
            && name == oth.name
            && ssl == oth.ssl
            && cert_file == oth.cert_file
            && key_file == oth.key_file
            && accept_worker == oth.accept_worker
            && io_worker == oth.io_worker
            && process_worker == oth.process_worker
            && args == oth.args
            && id == oth.id
            && type == oth.type;
    }
};

template<>
class LexicalCast<std::string, TcpServerConf>
{
public:
    TcpServerConf operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        TcpServerConf conf;
        conf.id             = node["id"].as<std::string>(conf.id);
        conf.type           = node["type"].as<std::string>(conf.type);
        conf.keepalive      = node["keepalive"].as<int>(conf.keepalive);
        conf.timeout        = node["timeout"].as<int>(conf.timeout);
        conf.name           = node["name"].as<std::string>(conf.name);
        conf.ssl            = node["ssl"].as<int>(conf.ssl);
        conf.cert_file      = node["cert_file"].as<std::string>(conf.cert_file);
        conf.key_file       = node["key_file"].as<std::string>(conf.key_file);
        conf.accept_worker  = node["accept_worker"].as<std::string>();
        conf.io_worker      = node["io_worker"].as<std::string>();
        conf.process_worker = node["process_worker"].as<std::string>();
        conf.args           = LexicalCast<std::string
            , std::map<std::string, std::string> >()(node["args"].as<std::string>(""));
        if(node["address"].IsDefined())
        {
            for(size_t i = 0; i < node["address"].size(); ++i)
            {
                conf.address.push_back(node["address"][i].as<std::string>());
            }
        }
        return conf;
    }
};

template<>
class LexicalCast<TcpServerConf, std::string>
{
public:
    std::string operator()(const TcpServerConf& conf)
    {
        YAML::Node node;
        node["id"]              = conf.id;
        node["type"]            = conf.type;
        node["keepalive"]       = conf.keepalive;
        node["timeout"]         = conf.timeout;
        node["name"]            = conf.name;
        node["ssl"]             = conf.ssl;
        node["cert_file"]       = conf.cert_file;
        node["key_file"]        = conf.key_file;
        node["accept_worker"]  = conf.accept_worker;
        node["io_worker"]       = conf.io_worker;
        node["process_worker"]  = conf.process_worker;
        node["args"]            = YAML::Load(LexicalCast<
                std::map<std::string, std::string>, std::string>()(conf.args));
        for(auto& i : conf.address)
        {
            node["address"].push_back(i);
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

/**
 * @brief   Tcp服务器封装
 */
class TcpServer : public std::enable_shared_from_this<TcpServer>
                  , Noncopyable
{
public:
    typedef std::shared_ptr<TcpServer> ptr;

    /**
     * @brief   
     *
     * @param   worker          好像没啥用，不知道是干嘛的
     * @param   io_worker       socket客户端工作的协程调度器
     * @param   accpet_worker   服务器socket执行接收socket连接的协程调度器
     */
    TcpServer(sylar::IOManager* worker = sylar::IOManager::GetThis()
            , sylar::IOManager* io_worker = sylar::IOManager::GetThis()
            , sylar::IOManager* accpet_worker = sylar::IOManager::GetThis());
    virtual ~TcpServer();

    virtual bool bind(sylar::Address::ptr addr, bool ssl = false);
    
    /**
     * @brief  绑定地址数组 
     */
    virtual bool bind(const std::vector<Address::ptr>& addrs
                    , std::vector<Address::ptr>& fails
                    , bool ssl = false);

    //bool loadCertificates(const std::string& cert_file, const std::string& key_file);

    /**
     * @brief  启动服务 
     */
    virtual bool start();
    virtual void stop();
    
    uint64_t getRecvTimeout() const { return m_recvTimeout; }
    void setRecvTimeout(uint64_t v) { m_recvTimeout = v; }

    /**
     * @brief  返回服务器名称 
     */
    std::string getName() const { return m_name; }
    virtual void setName(const std::string& v) { m_name = v; }

    bool isStop() const { return m_isStop; }

    TcpServerConf::ptr getConf() const { return m_conf; }
    void setConf(TcpServerConf::ptr v) { m_conf = v; }
    void setConf(const TcpServerConf& v);

    virtual std::string toString(const std::string& prefix = "");
    std::vector<Socket::ptr> getSocks() const { return m_socks; }

protected:
    /**
     * @brief  处理新连接的Socket类 
     */
    virtual void handleClient(Socket::ptr client);
    
    /**
     * @brief   开始接受连接
     */
    virtual void startAccept(Socket::ptr sock);

protected:
    /// 监听Socket数组
    std::vector<Socket::ptr> m_socks;
    /// 不知道有什么用
    IOManager* m_worker;
    /// 新连接的Socket工作的调度器
    IOManager* m_ioWorker;
    /// 服务器Socket接收连接的调度器
    IOManager* m_acceptWorker;
    /// 接收超时时间（毫秒）
    uint64_t m_recvTimeout;
    /// 服务器名称
    std::string m_name;
    /// 服务器类型
    std::string m_type = "tcp";
    /// 服务是否停止
    bool m_isStop;

    bool m_ssl = false;
    TcpServerConf::ptr m_conf;
};

}

#endif


#include "tcp_server.h"
#include "log.h"

namespace sylar
{
static sylar::ConfigVar<uint64_t>::ptr g_tcp_server_read_timeout = 
    sylar::Config::Lookup("tcp_server.read_timeout", (uint64_t)(60 * 1000 * 2),
            "tcp server read timeout");

static sylar::Logger::ptr g_logger = SYLAR_LOG_NAME("system");

TcpServer::TcpServer(sylar::IOManager* worker
        , sylar::IOManager* io_worker
        , sylar::IOManager* accept_worker)
    : m_worker(worker)
    , m_ioWorker(io_worker)
    , m_acceptWorker(accept_worker)
    , m_recvTimeout(g_tcp_server_read_timeout->getValue())
    , m_name("sylar/1.0.0")
    , m_isStop(true)
{
}

TcpServer::~TcpServer()
{
    for(auto& i : m_socks)
    {
        i->close();
    }
    m_socks.clear();
}

bool TcpServer::bind(sylar::Address::ptr addr, bool ssl)
{
    std::vector<Address::ptr> addrs;
    std::vector<Address::ptr> fails;
    addrs.push_back(addr);
    return bind(addrs, fails, ssl);
}

bool TcpServer::bind(const std::vector<Address::ptr>& addrs
                , std::vector<Address::ptr>& fails
                , bool ssl)
{
    m_ssl = ssl;
    for(auto& addr : addrs)
    {
        //Socket::ptr sock = ssl ? SSLSocket::CreateTCP(addr) : Socket::CreateTCP(addr);
        Socket::ptr sock = Socket::CreateTCP(addr);
        if(!sock->bind(addr))
        {
            SYLAR_LOG_ERROR(g_logger) << "bind fail errno="
                << errno << " errstr=" << strerror(errno)
                << " addr=(" << addr->toString() << "]";
            fails.push_back(addr);
            continue;
        }
        if(!sock->listen())
        {
            SYLAR_LOG_ERROR(g_logger) << "listen fail errno="
                << errno << " errstr=" << strerror(errno)
                << " addr=" << addr->toString() << "]";
            fails.push_back(addr);
            continue;
        }
        m_socks.push_back(sock);
    }

    if(!fails.empty())
    {
        m_socks.clear();
        return false;
    }

    for(auto& i : m_socks)
    {
        SYLAR_LOG_INFO(g_logger) << "type=" << m_type
            << " name=" << m_name
            << " ssl=" << m_ssl
            << " server bind success: " << *i;
    }
    return true;
}

/*bool TcpServer::loadCertificates(const std::string& cert_file, const std::string& key_file)
{
    for(auto& i : m_socks)
    {
        auto ssl_socket = std::dynamic_pointer_cast<SSLSocket>(i);
        if(ssl_socket)
        {
            if(!ssl_socket->loadCertificates(cert_file, key_file))
            {
                return false;
            }
        }
    }
    return true;
}*/

bool TcpServer::start()
{
    if(!m_isStop)
    {
        return true;
    }
    m_isStop = false;
    for(auto& sock : m_socks)
    {
        m_acceptWorker->schedule(std::bind(&TcpServer::startAccept,
                        shared_from_this(), sock));
    }
    return true;
}

void TcpServer::stop()
{
    m_isStop = true;

    // 这里传多一个self，应该为了引用计数加1，防止被过早析构掉
    auto self = shared_from_this();
    m_acceptWorker->schedule([this, self]() {
        for(auto& sock : m_socks)
        {
            sock->cancelAll();
            sock->close();
        }
        m_socks.clear();
    });
}

void TcpServer::setConf(const TcpServerConf& v)
{
    m_conf.reset(new TcpServerConf(v));
}

std::string TcpServer::toString(const std::string& prefix)
{
    std::stringstream ss;
    ss << prefix << "[type=" << m_type
       << " name=" << m_name << " ssl=" << m_ssl
       << " worker=" << (m_worker ? m_worker->getName() : "")
       << " accept=" << (m_acceptWorker ? m_acceptWorker->getName() : "")
       << " recv_timeout=" << m_recvTimeout << "]" << std::endl;
    std::string pfx = prefix.empty() ? "    " : prefix;
    for(auto& i : m_socks)
    {
        ss << pfx << pfx << *i << std::endl;
    }
    return ss.str();
}

void TcpServer::handleClient(Socket::ptr client)
{
    SYLAR_LOG_INFO(g_logger) << "handleClient: " << *client;    
}

void TcpServer::startAccept(Socket::ptr sock)
{
    while(!m_isStop)
    {
        Socket::ptr client = sock->accept();
        if(client)
        {
            client->setRecvTimeout(m_recvTimeout);
            m_ioWorker->schedule(std::bind(&TcpServer::handleClient,
                        shared_from_this(), client));
        }
        else
        {
            SYLAR_LOG_ERROR(g_logger) << "accept errno=" << errno
                << " errstr=" << strerror(errno);
        }
    }
}

}

广告时间：基于sylar框架实现的小demo(希望给个star)

基于redis的参数查询服务

江湖人称菠萝包
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http模块，TcpServer模块，Websocket模块，Https模块等，Smtp邮件模块，MySQL，SQLite3，ORM，Redis，Zookeeper）
01-30
`sylar-master`这个文件名可能指的是项目的源码主分支，包含了所有上述特性的实现代码。对于C++开发者来说，这个框架提供了全面的工具集，可以帮助他们快速开发出高性能的网络应用。无论是构建大型Web服务，还是设计...
重写sylar服务器框架：线程与协程模块
weixin_53026694的博客
07-08 187
基于ucontext_t实现非对称协程。
[学习分享]----sylar服务器框架源码阅读--IO协程调度模块
qq_49340792的博客
12-22 1123
epoll 是 Linux 系统提供的一种事件通知机制，主要用于处理大量文件描述符的 I/O 事件。它是一种高效的 I/O 多路复用机制，相比于传统的 select 和 poll，epoll 在处理大量连接时有更好的性能。
Sylar服务器框架---线程同步模块
qq_62821433的博客
05-12 369
1.sylar的线程同步模块使用了pthread线程库的互斥量，读写锁，自旋锁。原子锁是使用的c++的2.使用了RALL的方法，即资源构造即初始化，出作用域就析构。避免了我们手动进行资源申请和释放的相关操作。这里具体的操作是Mutex类创建一个对象时通过构造初始化锁，析构时销毁锁；加锁，解锁两个方法（用户不可自己调用）交由ScopedLockImpl<Mutex>类来调用，构造时就加锁，析构时解锁。和muduo中的基本一样。
【Python】《Python编程：从入门到实践 (第2版) 》笔记-Chapter9-类
江湖人称菠萝包
12-04 466
【Python】《Python编程：从入门到实践 (第2版) 》笔记-Chapter9-类
【CSS】Chapter2-CSS 复合选择器与特性
江湖人称菠萝包
05-28 105
选择器作用特征使用情况隔开符号及用法后代选择器用来选择后代元素可以是子孙后代较多符号是空格.nav a子代选择器选择最近一级元素只选亲儿子较少符号是大于.nav>p并集选择器选择某些相同样式的元素可以用于集体声明较多符号是逗号链接伪类选择器选择不同状态的链接跟链接相关较多重点记住a{}和a:hover{}实际开发的写法:focus 选择器选择获得光标的表单跟表单相关较少记住这个写法。
sylar服务器框架分析——日志系统
JMasker的博客
11-10 1301
sylar服务器框架中对于日志系统的重点难点分析
sylar-env-1.1.0-1.el7.x86_64.rpm
04-20
sylar-env-1.1.0-1.el7.x86_64.rpm
Sylar:学习开发Sylar服务器框架
03-29
Sylar-master文件夹很可能是项目源码的根目录，包含项目的头文件、源文件、构建脚本等。通过阅读源码，我们可以更深入地了解Sylar的内部机制和设计思想。 总之，Sylar服务器框架是一个结合了C++强大特性和高效网络...
C++聊天室服务器，基于sylar框架开发，使用http服务器做资源服务，
最新发布
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。...
CPU-Z，参数解读
03-10
CPU-Z--参数解读文档，
重写sylar服务器框架：配置模块
weixin_53026694的博客
07-07 277
可用于定义/声明配置项，并且从配置文件（YAML文件）中加载用户配置。一个配置项包含名称（对应着一个字符串，必须唯一，不能与其他配置项产生冲突），类型（支持基本类型和复杂类型，自定义类型需要做偏特化），值，配置项描述。采用约定优于配置，也称作按约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量，获得简单的好处，而又不失灵活性。
Redis安装与启动（linux下）
qq_24095055的博客
07-26 345
文章目录安装Redis配置、启动、操作、关闭Redis 安装Redis linux的安装只需要以下六步即可完成，本文以3.0.7版本为例： $ wget http://download.redis.io/releases/redis-3.0.7.tar.gz $ tar xzf redis-3.0.7.tar.gz $ ln -s redis-3.0.7 redis $ cd redis $ ma...
【Python】《Python编程：从入门到实践 (第2版) 》笔记-Chapter5-if 语句
江湖人称菠萝包
12-04 178
【Python】《Python编程：从入门到实践 (第2版) 》笔记-Chapter5-if 语句
[学习分享]----sylar服务器框架源码阅读--线程模块
qq_49340792的博客
10-13 262
sylar服务器框架学习分享
C++高性能服务器框架 – SYLAR简介
sylar的专栏
06-13 7605
视频地址 [C++高级教程]从零开始开发服务器框架(sylar) 视频教程内容： 1.日志模块 支持流式日志风格写日志和格式化风格写日志，支持日志格式自定义，日志级别，多日志分离等等功能 流式日志使用：SYLAR_LOG_INFO(g_logger) << “this is a log”; 格式化日志使用：SYLAR_LOG_FMT_INFO(g_logger, “%s”, “this...
【sylar】框架篇-Chapter1-搭建开发环境
江湖人称菠萝包
07-24 1112
【sylar】框架篇-Chapter1-搭建开发环境。
C++高性能服务器框架 - sylar
sylar的专栏
05-21 9631
C++高性能服务器框架 - sylarsylar视频教程地址开发环境项目路径日志系统配置系统日志系统整合配置系统协程库封装socket函数库http协议开发分布协议推荐系统其他信息 sylar 视频教程地址 C++服务器框架01_日志系统01 C++服务器框架02_日志系统02_logger C++服务器框架03_日志系统03_appender C++服务器框架04_日志系统04_formatt...
sylar高性能服务器-配置(P10-p11)代码解析+调试分析
qq_18824403的博客
12-12 357
本节内容主要是通过使用yaml-cpp库从yaml文件中读取配置信息，下面内容主要记录配置yaml的步骤以及对sylar使用yaml-cpp里面的方法进行一个简单解释。
shell scp -r命令
03-15
shell中的scp命令用于在本地主机和远程主机之间复制文件或目录。使用scp命令可以通过网络安全地传输文件。下面是使用scp命令复制文件或目录的示例[^2]： ```shell scp -r source_directory username@destination_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值