基于c++和asio的网络编程框架asio2教程使用篇：使用rpc模块编写rpc server和rpc client

int add(int a, int b)
{
	return a + b;
}

asio2::rpc_server server;

server.bind("add", add); // 绑定rpc函数，第1个参数是字符串，表示rpc函数的名字是什么，第2个参数是真正的rpc函数

server.start("0.0.0.0", 8010); // 启动服务端

asio2::rpc_client client;
	
client.start("127.0.0.1", 8010); // 连接服务端

int sum = client.call<int>("add", 1, 2); // 调用rpc函数，得到结果：sum == 3

// 最简单的同步调用如下：
// 第1个参数是个字符串，表示rpc函数的名字，后面的参数表示rpc函数的参数（这里的1,2即是add函数的参数）
int sum = client.call<int>("add", 1, 2);

// 如果函数调用失败，怎么办？在哪里获取通知？
int sum = client.call<int>("add", 1, 2);
// 使用asio2::get_last_error()来判断是否发生错误
if (asio2::get_last_error()) // 有错误
	printf("add failed : %d %s\n", asio2::last_error_val(), asio2::last_error_msg().c_str());

// 怎么设置同步调用的超时时间？
int sum = client.call<int>(std::chrono::seconds(3), "add", 1, 2);

// 最简单的异步调用如下：
// 第1个参数是回调函数，后面的参数是rpc函数名称和rpc函数参数
// 回调函数的参数即是rpc函数的返回值
client.async_call([](int sum)
{
	if (!asio2::get_last_error()) // 没有错误
	{
		ASIO2_ASSERT(sum == 1 + 2);
	}
	else // 有错误
	{
		printf("error : %d %s\n", asio2::last_error_val(), asio2::last_error_msg().c_str());
	}
}, "add", 1, 2);

// 如何指定异步调用的超时时间？
client.async_call([](int sum)
{
}, std::chrono::seconds(3), "add", 1, 2);

// 如果rpc函数返回值是void怎么办？
// 比如有个心跳函数:
void heartbeat(){}
// 那么可以像下面这样调用即可，也就是说回调函数参数为空即可
client.async_call([]()
{
}, std::chrono::seconds(3), "heartbeat");

// 如果你不关心调用结果，也就是说不关心rpc函数的返回值，你可以直接调用，可以不关心调用成功还是失败，
// 这种情况下当服务器收到rpc请求后，是不会给客户端回复的。
client.async_call("heartbeat");

// 同步调用的链式调用，如下：
int sum = client.call<int>("add", 1, 2); // ok
int sum = client.timeout(std::chrono::seconds(3)).call<int>("add", 1, 2); // ok
// 同步调用时.call函数必须在链的最后一个
int sum = client.call<int>("add", 1, 2).timeout(std::chrono::seconds(3)); // 错误 

// 异步调用的链式调用，如下：
client.timeout(std::chrono::seconds(3)).response([](int sum){}).async_call("add", 1, 2); // ok
client.response([](int sum){}).timeout(std::chrono::seconds(3)).async_call("add", 1, 2); // ok
// 异步调用时async_call可以在链的任意位置 所以下面都是正确的
client.async_call("add", 1, 2).timeout(std::chrono::seconds(3)).response([](int sum){}); // ok 
client.timeout(std::chrono::seconds(3)).async_call("add", 1, 2).response([](int sum){}); // ok 
client.response([](int sum){}).async_call("add", 1, 2); // ok
client.async_call("add", 1, 2).response([](int sum){}); // ok

// bind_connect是server提前绑定的回调函数，当有一个客户端连接上来之时，此回调函数会被调用，关于bind_connect知识请参考其它文章。
// 当然，并不是只能在bind_connect这里，也可以在其它地方调用客户端的rpc函数。
server.bind_connect([&](auto & session_ptr)
{
	// 这里session_ptr表示客户端的连接对象
	// 这个客户端连接上来之后，server通过session_ptr向该客户端发起一个rpc函数调用
	session_ptr->async_call([](int v)
	{
		if (!asio2::get_last_error())
		{
			ASIO2_ASSERT(v == 15 - 6);
		}
	}, std::chrono::seconds(5), "sub", 15, 6);
});

// server端提前绑定一个rpc函数"cat"（这里这个rpc函数是个lambda函数）
server.bind("cat", [&](std::shared_ptr<asio2::rpc_session>& session_ptr, std::string a, std::string b)
{
	// 当客户端调用rpc函数"cat"时，会执行到这里来.....

	// server端收到客户端的调用请求时，在这里用session_ptr嵌套的给该client发送一个rpc调用请求
	session_ptr->async_call([session_ptr](int v) mutable
	{
		// 当server端发送的调用请求，收到了回复时，再次嵌套的给该client发送一个rpc调用请求，如此等等。
		session_ptr->async_call([](int v)
		{
			if (!asio2::get_last_error())
			{
				ASIO2_ASSERT(v == 15 + 18);
			}
			printf("async_add : %d err : %d %s\n", v, asio2::last_error_val(), asio2::last_error_msg().c_str());
		}, "add", 15, 18);

		if (!asio2::get_last_error())
		{
			ASIO2_ASSERT(v == 15 - 8);
		}
		printf("sub : %d err : %d %s\n", v, asio2::last_error_val(), asio2::last_error_msg().c_str());
	}, "sub", 15, 8);

	return a + b;
});

int add(int a, int b)
{
	return a + b;
}

// 将rpc函数的第1个参数改为连接对象的指针，如下，此时通过session_ptr就能知道是哪个client调用的了
// 当然，如果你不关心是哪个client调用的，那么std::shared_ptr<asio2::rpc_session>& session_ptr这个参数可以不要，
// 也就是说下面这种带session_ptr的方式和上面那种不带session_ptr的方式，都支持，而且都只需server.bind("add", add)
// 即可，不同的版本不需要其它不同的bind操作。
int add(std::shared_ptr<asio2::rpc_session>& session_ptr, int a, int b)
{
	return a + b;
}

int add(int a, int b)
{
	// 调用get_current_caller函数直接获取即可(注意模板参数必须完全匹配)
	std::shared_ptr<asio2::rpc_session> session_ptr = 
		asio2::get_current_caller<std::shared_ptr<asio2::rpc_session>>();
	return a + b;
}

struct userinfo
{
	std::string name;
	int age;
	std::map<int, std::string> purview;
};

userinfo get_user(std::string name)
{
	// 根据参数name找到对应的userinfo并返回（这里不再写“根据name找到userinfo”的代码了）
	userinfo u;
	u.name = name;
	u.age = 100;
	u.purview = { {1,"read"},{2,"write"} };
	return u;
}

struct userinfo
{
	std::string name;
	int age;
	std::map<int, std::string> purview;

	// 添加一个模板形式的序列化函数，函数名称和函数参数必须保持和下面示例的一样才行。
	template <class Archive>
	void serialize(Archive & ar)
	{
		ar(name);
		ar(age);
		ar(purview);
	}
};

nlohmann::json test_json(nlohmann::json j)
{
	std::string s = j.dump();

	return nlohmann::json::parse(s);
}

void operator<<(asio2::rpc::oarchive& sr, const nlohmann::json& j)
{
	sr << j.dump(); // j.dump()是把json对象转换为std::string
}

void operator>>(asio2::rpc::iarchive& dr, nlohmann::json& j)
{
	std::string v;
	dr >> v;
	j = nlohmann::json::parse(v); // json::parse(v) 是把std::string转换为json对象
}

int add(int a, int b)
{
	int result;

	// 当收到rpc调用时，需要交给其它的工作线程中去异步处理
	std::thread([&result, a, b]() mutable
	{
		result = a + b; // 此时处理完毕，才有了结果
	}).detach();

	// return result; // 这里如果直接返回result是不对的，因为上面的异步调用无法确定在什么时候才会完成
}

// 第1，函数的返回值要用rpc::future包裹起来
rpc::future<int> add(int a, int b)
{
	// 第2，定义两个辅助变量，promise和future ，如下：
	rpc::promise<int> promise;
	rpc::future<int> f = promise.get_future();

	// 第3，把promise传到那个异步的工作线程中
	std::thread([a, b, promise = std::move(promise)]() mutable
	{
		// ...... 比如这里经过了很多工作处理......
		// 第4，处理完毕后，给promise设置值，这个值就是这个add函数的返回值了
		promise.set_value(a + b);

		// 代码执行到这里之后，promise变量会析构，当promise析构时，asio2框架就会自动给客户端回复了，
		// 回复时的结果就是上面promise.set_value函数中设置的那个值。
	}).detach();

	// 第5，在这里返回上面那个定义的变量future即可。注意比较和同步rpc函数的区别，同步rpc函数直接返回了a+b;
	return f;
}

client.set_default_timeout(std::chrono::seconds(3));