Skynet专题之：信号

// 信号设置函数
int sigign() {
	struct sigaction sa;
	sa.sa_handler = SIG_IGN;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGPIPE, &sa, 0);
	return 0;
}

// struct sigaction 结构体定义了信号的处理方式和相关的属性
// 用于设置和处理信号的行为，包括信号处理函数、信号的屏蔽集合和标志等
struct sigaction {
    void (*sa_handler)(int); // 信号处理函数
    void (*sa_sigaction)(int, siginfo_t *, void *); // 信号处理函数（扩展版本）
    sigset_t sa_mask; // 信号屏蔽集合
    int sa_flags; // 信号处理标志
    void (*sa_restorer)(void); // 用于恢复信号处理的函数（已弃用）
};

// 下面依次解释字段的含义和作用
// sa_handler：指向信号处理函数的指针，用于处理接收到的信号。当信号发生时，系统会调用指定的信号处理函数来处理该信号
// sa_sigaction：扩展版本的信号处理函数指针，可以接收更多的信号相关信息，如信号的来源和附加数据等
// sa_mask：用于设置信号处理函数执行期间要屏蔽的信号集合。在信号处理函数执行期间，可以通过设置 sa_mask 来阻塞其他信号的传递
// sa_flags：用于设置信号处理的标志，例如设置为 SA_RESTART 可以使被信号中断的系统调用自动重启
// sa_restorer：已弃用的字段，用于指定在信号处理函数执行完毕后恢复信号处理的函数

// sa_handler 函数例子
// 它的主要作用是指定当信号到达时要执行的函数
void handle_signal(int signal) {
    printf("Received signal %d\n", signal); 
} 

// 赋值给 sa_handler，这样信号到达时，操作系统就会执行 handle_signal()
sa.sa_handler = handle_signal;

// sigaction(SIGPIPE, &sa, 0) 是一个函数调用，用于设置对 SIGPIPE 信号的处理方式
// SIGPIPE 信号是在进程尝试向一个已关闭的管道或套接字写入数据时产生的信号
// 可以看信号的类型13

// 函数原型
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)

// signum 是要设置处理方式的信号编号，这里是 SIGPIPE
//
// act 是一个指向 struct sigaction 结构体的指针，用于指定信号的处理方式
// 
// oldact 是一个指向 struct sigaction 结构体的指针，用于获取之前的信号处理方式
// 通过它，可以获取之前对同一信号注册的处理函数和标志
// 当你调用 sigaction() 函数再次设置新的信号处理方式时，如果传递了非空的 oldact 参数
// 系统会将之前的信号处理方式存储在该结构体中，以便你可以在之后需要时进行参考
// 传递的是 0，表示不获取之前的处理方式

// 通过调用 sigaction(SIGPIPE, &sa, 0)，将会设置对 SIGPIPE 信号的处理方式为 sa 所指定的方式
// sa 是一个 struct sigaction 结构体，其中包含了信号处理函数和其他相关的设置，就是我们前面建立的 struct sigaction sa

// 信号设置函数
int sigign() {
	struct sigaction sa;
	sa.sa_handler = SIG_IGN;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGPIPE, &sa, 0);
	return 0;
}

// register SIGHUP for log file reopen
struct sigaction sa;
sa.sa_handler = &handle_hup;
sa.sa_flags = SA_RESTART;
sigfillset(&sa.sa_mask);
sigaction(SIGHUP, &sa, NULL);

// 在前面，即 skynet_main.c 文件中，第131行的sigign()函数
// 首先调用了 sigign() 函数将 SIGPIPE 信号的处理方式设置为忽略，将导致 SIGPIPE 信号被忽略，不会中断程序的执行
// 
// 然后这里创建了一个新的 struct sigaction 结构体 sa
// 将其 sa_handler 成员设置为指向 handle_hup 函数的指针
// 并将 sa_flags 设置为 SA_RESTART
// 最后使用 sigfillset(&sa.sa_mask) 将信号屏蔽集合 sa.sa_mask 清空
// 并调用 sigaction() 函数将 SIGHUP 信号的处理方式设置为 sa
// 最后的结果：SIGPIPE 信号的处理方式不会被覆盖，它仍然将保持为忽略，而 SIGHUP 信号的处理方式将被设置为 handle_hup 函数
// 
// 并且因为 SIGPIPE 信号设置的是：sigemptyset(&sa.sa_mask)，因此在处理 SIGPIPE 信号时，不会阻塞其他信号
// 而 SIGHUP 信号设置的是：sigfillset(&sa.sa_mask)，因此在处理 SIGHUP 信号时，会阻塞所有其它能被阻塞的信号
// 
// SIGHUP是指终端挂起或进程结束
// 也就是说：当skynet的终端被挂起的时候，将会执行 sa.sa_handler = handle_hup 函数

static void
handle_hup(int signal) {
	if (signal == SIGHUP) {
		SIG = 1; // 收到SIGHUP，把SIG置为1
	}
}

static void *
thread_timer(void *p) {
	// 忽略代码
	for (;;) {
		// 忽略代码
		usleep(2500);
		if (SIG) {
			signal_hup();
			SIG = 0; // 执行一次 signal_hup()，然后把 SIG 重设为0，代表着这次信号已经处理了
		}
	}
	// 忽略代码
}

// 我们看看 signal_hup() 具体做了什么
// 等于说给 logger 服务发了一个消息
static void
signal_hup() {
	// make log file reopen
	struct skynet_message smsg;
	smsg.source = 0;
	smsg.session = 0;
	smsg.data = NULL;
    // 这里直接把 消息类型 编码进sz的高8位
    // 验证：
    // 		skynet.server.c文件中，dispatch_message函数中，有：int type = msg->sz >> MESSAGE_TYPE_SHIFT;
    // 		skynet_mq.h文件中，有注释：type is encoding in skynet_message.sz high 8bit
    // 		云风的blog也有解释:
    //			https://blog.codingnow.com/2012/09/the_design_of_skynet.html
    // 			type 表示的是当前消息包的协议组别，而不是传统意义上的消息类别编号
    //			协议组别类型并不会很多，所以，我限制了 type 的范围是 0 到 255 ，由一个字节标识
    //			在实现时，我把 type 编码到了 size 参数的高 8 位
    //			因为单个消息包限制长度在 16 M （24 bit)内，是个合理的限制
    //			这样，为每个消息增加了 type 字段，并没有额外增加内存上的开销
	smsg.sz = (size_t)PTYPE_SYSTEM << MESSAGE_TYPE_SHIFT;
	uint32_t logger = skynet_handle_findname("logger");
	if (logger) {
		skynet_context_push(logger, &smsg);
	}
}

static int
logger_cb(struct skynet_context * context, void *ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
	struct logger * inst = ud;
	switch (type) {
	case PTYPE_SYSTEM: 
        // 我们可以看到这里有对 type == PTYPE_SYSTEM 的特殊处理
        // 为什么是 freopen() 呢？
        // 即：为什么关闭终端后，是 freopen() 文件呢？
        // 看代码段1
		if (inst->filename) {
			inst->handle = freopen(inst->filename, "a", inst->handle);
		}
        // freopen() 是一个 C 语言标准库函数，用于重新定向一个文件流（比如 stdin、stdout 或 stderr）到一个指定的文件
        // filename 是一个字符串，表示要打开的文件名
        // mode 是一个字符串，表示打开文件的模式
        // stream 是一个文件流，可以是 stdin、stdout、stderr
        //
        // 在《Skynet源码之：守护进程》中，已经将stdin、stdout、stderr重定向至"/dev/null"
        // 而 freopen()用于将把 stdin、stdout、stderr重定向至日志文件
		break;
	case PTYPE_TEXT:
		if (inst->filename) {
			char tmp[SIZETIMEFMT];
			int csec = timestring(ud, tmp);
			fprintf(inst->handle, "%s.%02d ", tmp, csec);
		}
		fprintf(inst->handle, "[:%08x] ", source);
		fwrite(msg, sz , 1, inst->handle);
		fprintf(inst->handle, "\n");
		fflush(inst->handle);
		break;
	}

	return 0;

}

int
logger_init(struct logger * inst, struct skynet_context *ctx, const char * parm) {
	const char * r = skynet_command(ctx, "STARTTIME", NULL);
	inst->starttime = strtoul(r, NULL, 10);
    
    // ********************************* 重点关注这段代码 *********************************
	if (parm) {
        // 这个 parm 就是用户在 config 配置中，填写的 logger 日志的文件目录
		inst->handle = fopen(parm, "a");
		if (inst->handle == NULL) {
			return 1;
		}
		inst->filename = skynet_malloc(strlen(parm)+1);
		strcpy(inst->filename, parm);
		inst->close = 1;
	} else {
		inst->handle = stdout; // 如果用户没有配置，那就直接使用标准输出
	}
    // ********************************* 重点关注这段代码 *********************************
    // 也就是说，如果你需要Skynet把日志输入到指定文件
    // 那你就需要在 config 配置一个 logger 字段，填写日志的目录和名字
    // 一般同时在 config 配置一个daemon
    // 这个时候Skynet就会进入后台，并且把日志输出到配置的文件中
    
	if (inst->handle) {
		skynet_callback(ctx, inst, logger_cb);
		return 0;
	}
	return 1;
}