sylixos架构图 systolic架构

转载

恋上一只猪 2023-11-10 11:06:55

文章标签 sylixos架构图服务器 c++ YAML 序列化 文章分类 架构后端开发

此项目是根据sylar框架实现，是从零开始重写sylar，也是对sylar丰富与完善

简介

项目介绍：实现了一个基于协程的服务器框架，支持多线程、多协程协同调度；支持以异步处理的方式提高服务器性能；封装了网络相关的模块，包括socket、http、servlet等，支持快速搭建HTTP服务器或WebSokcet服务器。
详细内容：日志模块，使用宏实现流式输出，支持同步日志与异步日志、自定义日志格式、日志级别、多日志分离等功能。线程模块，封装pthread相关方法，封装常用的锁包括（信号量，读写锁，自旋锁等）。IO协程调度模块，基于ucontext_t实现非对称协程模型，以线程池的方式实现多线程，多协程协同调度，同时依赖epoll实现了事件监听机制。定时器模块，使用最小堆管理定时器，配合IO协程调度模块可以完成基于协程的定时任务调度。hook模块，将同步的系统调用封装成异步操作（accept, recv, send等），配合IO协程调度能够极大的提升服务器性能。Http模块，封装了sokcet常用方法，支持http协议解析，客户端实现连接池发送请求，服务器端实现servlet模式处理客户端请求，支持单Reator多线程，多Reator多线程模式的服务器。

配置模块

sylixos架构图 systolic架构_服务器

1. 主要功能

支持yaml格式的配置文件解析
使用模板完成基础类型，复杂类型（vector、map、set等），自定义类型的序列化与反序列化
利用回调机制，在加载配置时，完成配置的更新
使用yaml-cpp库，实现配置文件读取
约定大于配置

2. 功能演示

配置文件test.yaml

tcp:
    connect:
            timeout: 10000

// 约定的配置
ConfigVar<int>::ptr tcp_config = Config::Lookup("tcp.connect.timeout", 5000, "tcp connect timeout");

LOG_INFO(LOG_ROOT()) << "before: " << tcp_config->getValue();	// before: 5000

// 读取配置文件
YAML::Node root = YAML::LoadFile("test.yaml");
// 加载配置文件，并更改配置值
Config::LoadFromYaml(root);

LOG_INFO(LOG_ROOT()) << "after: " << tcp_config->getValue();	// after: 10000

3. 模块介绍

3.1 ConfigVarBase

配置基本信息。基类。

class ConfigVarBase
{
public:
	typedef std::shared_ptr<ConfigVarBase> ptr;
	ConfigVarBase(const std::string& name, const std::string& description = "")
		:m_name(name)
		,m_description(description)
	{
		//把名字都转换成小写
		std::transform(m_name.begin(), m_name.end(), m_name.begin(), ::tolower);
	}

	virtual ~ConfigVarBase() {}
	
	//get, set方法

	virtual std::string toString() = 0;						// 序列化，转换成string
	virtual bool fromString(const std::string& val) = 0;	/
protected:
	std::string m_name;					/// 配置的字段的名字
	std::string m_description;			/// 字段的描述
};

3.2 ConfigVar

配置变量。使用模板的方式完成基本类型，复杂类型（vector、map、set等），自定义类型的序列化和反序列化

template<class T, class FromStr = LexicalCast<std::string, T>
					, class ToStr = LexicalCast<T, std::string>>
class ConfigVar : public ConfigVarBase
{
public:
		typedef RWMutex RWMutexType;
		typedef std::shared_ptr<ConfigVar> ptr;
		typedef std::function<void (const T& old_value, const T& new_value)> on_change_cb;
		std::string toString() override;
		bool fromString(const std::string& val) override;
		uint64_t addListener(on_change_cb cb);
		
private:
	T m_val;									///	配置变量
	std::map<uint64_t, on_change_cb> m_cbs;		/// 回调函数，当配置有改变时，回调
	RWMutexType m_mutex;						/// 读写锁，读多写少
}

使用模板实现序列化与反序列化

ConfigVar 是一个模板类template<class T, class FromStr = LexicalCast<std::string, T>, class ToStr = LexicalCast<T, std::string>>，其中FromStr完成序列化（string to value）；ToStr完成反序列化（value to string）。
基本类型。F类型转为T类型

/**
 * @brief 类型转换模板类(F 源类型, T 目标类型)
 */
template<class F, class T>
class LexicalCast {
public:
	/**
	 * @brief 类型转换
	 * @param[in] v 源类型值
	 * @return 返回v转换后的目标类型
	 * @exception 当类型不可转换时抛出异常
	 */
	T operator()(const F& v) {
		return boost::lexical_cast<T>(v);
	}
};

vector的序列化与反序列化。

/**
 * @brief 类型转换模板类片特化(YAML String 转换成 std::vector<T>)
 */
template<class T>
class LexicalCast<std::string, std::vector<T> > {
public:
	std::vector<T> operator()(const std::string& v) {
		//"yaml string [1,2,3] 转换成yaml node"
		YAML::Node node = YAML::Load(v);
		typename std::vector<T> vec;
		std::stringstream ss;
		for (size_t i = 0; i < node.size(); ++i) {
			ss.str("");
			ss << node[i];
			vec.push_back(LexicalCast<std::string, T>()(ss.str()));
		}
		return vec;
	}
};

/**
 * @brief 类型转换模板类片特化(std::vector<T> 转换成 YAML String)
 */
template<class T>
class LexicalCast<std::vector<T>, std::string> {
public:
	std::string operator()(const std::vector<T>& v) {
		YAML::Node node(YAML::NodeType::Sequence);
		for (auto& i : v) {
			node.push_back(YAML::Load(LexicalCast<T, std::string>()(i)));
		}
		std::stringstream ss;
		ss << node;
		return ss.str();
	}
};

map的序列化与反序列化。

/**
 * @brief 类型转换模板类片特化(YAML String 转换成 std::map<std::string, T>)
 */
template<class T>
class LexicalCast<std::string, std::map<std::string, T> > {
public:
	std::map<std::string, T> operator()(const std::string& v) {
		YAML::Node node = YAML::Load(v);
		typename std::map<std::string, T> vec;
		std::stringstream ss;
		for (auto it = node.begin();
			it != node.end(); ++it) {
			ss.str("");
			ss << it->second;
			vec.insert(std::make_pair(it->first.Scalar(),
				LexicalCast<std::string, T>()(ss.str())));
		}
		return vec;
	}
};

/**
 * @brief 类型转换模板类片特化(std::map<std::string, T> 转换成 YAML String)
 */
template<class T>
class LexicalCast<std::map<std::string, T>, std::string> {
public:
	std::string operator()(const std::map<std::string, T>& v) {
		YAML::Node node(YAML::NodeType::Map);
		for (auto& i : v) {
			node[i.first] = YAML::Load(LexicalCast<T, std::string>()(i.second));
		}
		std::stringstream ss;
		ss << node;
		return ss.str();
	}
};

自定义类型的序列化与反序列化将在后文讲解

ConfigVar如何完成序列化与反序列化

ConfigVar的模板 template<class T, class FromStr = LexicalCast<std::string, T>, class ToStr = LexicalCast<T, std::string>>。这里使用了模板偏特化，如果T是普通类型（int），会自动匹配到LexicalCast<std::string, int>；如果T是复杂类型（vector<int>）,会自动匹配到LexicalCast<std::string, vector<int>>。
仿函数实现序列化

//T to string YAML string
std::string toString() override
{
	try
	{
		RWMutexType::ReadLock lock(m_mutex);
		return  ToStr()(m_val);		// ToStr()(m_val)是仿函数，实际上是因为我们重写了operator()
	}
	catch (std::exception& e)
	{
		LOG_ERROR(LOG_ROOT()) << "ConfigVar::toString exception"
			<< e.what() << " convert: " << typeid(m_val).name() << " to string";
	}

	return "";

}

仿函数实现反序列化

//YAML string to T
bool fromString(const std::string& val) override
{
	try
	{
		setValue(FromStr()(val));	// FromStr()(val)是仿函数，实际上是因为我们重写了operator()
		return true;
	}
	catch (std::exception& e)
	{
		LOG_ERROR(LOG_ROOT()) << "ConfigVar::fromString exception"
			<< e.what() << " convert: string to" << typeid(m_val).name();
	}

	return false;
}

回调机制。加载时完成配置更新。当fromString()时，会调用setValue()，此时会根据新值和旧值，判断是否需要调用回调，完成配置更新

typedef std::function<void (const T& old_value, const T& new_value)> on_change_cb;	// 回调函数的类型
std::map<uint64_t, on_change_cb> m_cbs;		/// 该配置的所有回调

// 添加监听器
uint64_t addListener(on_change_cb cb)
{
	//每次由系统决定key值，再返回，用于delListener
	static uint64_t s_idx = 0;
	RWMutexType::WriteLock lock(m_mutex);	
	++s_idx;
	m_cbs[s_idx] = cb;
	return s_idx;
}

// 设置配置值
void setValue(const T& value) 
{
	{
		RWMutexType::ReadLock lock(m_mutex);
		
		if (value == m_val) return;

		//只有当old 和 new不同时才回调
		for (auto& i : m_cbs)
		{
			i.second(m_val, value);
		}
	}
	RWMutexType::WriteLock lock(m_mutex);
	m_val = value; 
}

这里使用了读写锁保证线程安全，因为配置模块主要是读多写少，能保证最大效率

3.3 Config

配置管理。负责管理所有的配置信息static ConfigVarMap s_datas

//管理类
class Config
{
public:
	typedef RWMutex RWMutexType;
	typedef std::map<std::string, ConfigVarBase::ptr> ConfigVarMap;

	//查找一个配置变量，没找到就创建一个新的，放到s_datas
	//name：A.B
	template<class T>
	static typename ConfigVar<T>::ptr Lookup(const std::string& name, const T& default_value, const std::string& description = "");
	
	//查找name
	template<class T>
	static typename ConfigVar<T>::ptr Lookup(const std::string& name);
	//解析yaml文件，读取配置信息
	static void LoadFromYaml(const YAML::Node& root);
	//查看当前配置表的信息
	static void Visit(std::function<void(johnsonli::ConfigVarBase::ptr)> cb);
	
private:
	//查找name，返回ConfigVarBase::ptr
	static ConfigVarBase::ptr LookupBase(const std::string& name);
	
private:
	/**
	 * @brief 返回所有的配置项
	*/
	static ConfigVarMap& GetDatas() {
		static ConfigVarMap s_datas;
		return s_datas;
	}
	
	//如果是静态成员变量，可能对象会先创建出来，但是静态变量还没有初始化
	static RWMutexType& GetMutex()
	{
		static RWMutexType s_mutex;
		return s_mutex;
	}

};

自定义类型的序列化与反序列化

由于需要完成对日志的配置，因此需要完成对日志器的序列化与反序列化。这里我们需要先抽取出两个结构体 struct LogAppenderDefine与struct LogDefine。

//LogAppender
struct LogAppenderDefine
{
	int type = 0; //1 File, 2 Stdout
	LogLevel::Level level = LogLevel::UNKNOW;
	std::string formatter;
	std::string file;
	
	bool operator==(const LogAppenderDefine& oth) const
	{
		return type == oth.type
			&& level == oth.level
			&& formatter == oth.formatter
			&& file == oth.file;
	}
};

//Logger
struct LogDefine
{
	std::string name;
	LogLevel::Level level = LogLevel::UNKNOW;
	std::vector<LogAppenderDefine> appenders;
	
	bool operator==(const LogDefine& oth) const
	{
		return name == oth.name
			&& level == oth.level
			&& appenders == oth.appenders;
	}

	bool operator<(const LogDefine& oth) const
	{
		return name < oth.name;
	}
};

struct LogDefine表示日志器的配置信息，因此需要完成日志器的序列化与反序列化

//LogDefine偏特化 YAML string to LogDefine
template<>
class LexicalCast<std::string, LogDefine>
{
public:
	LogDefine operator()(const std::string& str){...}
};

//LogDefine偏特化 LogDefine to YAML string 
template<>
class LexicalCast<LogDefine, std::string> 
{
public:
	std::string operator()(const LogDefine& i) {...}
};

在加载日志配置时，我们添加了回调函数，实现在加载时就完成配置更改

ConfigVar<std::set<LogDefine>>::ptr g_log_defines = Config::Lookup("logs", std::set<LogDefine>(), "logs config");
// LoadFromYaml（YAML string to T） --> 在SetValue中观察者模式触发日志更改事件 --> 调用回调函数(添加、修改、删除) 
struct  LogIniter
{
	LogIniter()
	{
		g_log_defines->addListener([] (const std::set<LogDefine>& old_val, const std::set<LogDefine>& new_val) 
		{
			// 添加，new_val有，old_val没有
			// 修改，new_val有，old_val有，但不相同
			// 删除，new_val没有，old_val有
		}
	}
};
static LogIniter __log_init;

这里使用了一个方法，使得添加回调函数的执行在main函数之前。在类的构造函数中处理，声明静态变量，这样就会在main函数之前进行构造，完成处理。

日志配置的格式

logs:
  - name: root
    level: debug
    appenders:
      - type: FileLogAppender
        level: debug
        file: root.log
        formatter: "%d%TF%T[%p]%T[%c]%T%f:%l%T%m%n"
      - type: StdoutLogAppender
        level: debug
        formatter: "%d{%Y-%m-%d %H:%M:%S}%T%t%T%N%T%F%T[%p]%T[%c]%T%f:%l%T%m%n"
  - name: system
    level: debug
    appenders:
      - type: FileLogAppender
        level: debug
        file: root.log
        formatter: "%d%TF%T[%p]%T[%c]%T%f:%l%T%m%n"
      - type: StdoutLogAppender
        level: debug
        formatter: "%d{%Y-%m-%d %H:%M:%S}%T%t%T%N%T%F%T[%p]%T[%c]%T%f:%l%T%m%n"