POE::Wheel::Run示例详解

一、POE简介

perl的POE模块是一个事件驱动的有限状态机编程框架，

它用一个单进程模拟多线程的多任务执行模块，

并提供的非阻塞的IO操作(就像C语言下面的libevent库)。

它能干的事情很多，并且写起来代码很清晰，可读性非常好。

POE最重要的一点是，它尝试着把在事件驱动环境中编程的恼人细节给隐藏起来。

POE的组成部分包括:

states(状态),kernel(内核),session(任务),driver(驱动),filter,wheel和component等。

states: 就是有限状态机中的状态，

对应着的就是处理这些状态的句柄--也就是函数。

kernel: 是POE的核心模块.

POE的内核与OS的内核很相似: 它会跟踪后台的所有进程和数据，并调度运行的代码。

可以用内核来设置POE进程的时钟，将要运行的状态进行排队，和执行各种低级服务，

但在很多时候，并不需要直接和内核进行交互。

session:它等同于OS中的进程。

session是从一个状态切换到另一个状态时运行的POE程序。

它可以创建子session，发送POE事件给其它session等。

每个session都有一个名为head的哈希表，可以用来存储本session的私有数据，

并且该session中的每个状态处理函数都可访问它。

POE是一个很精简的多任务协作模型;

所有的session都是在同个OS进程中执行，其本身上不是多线程或多进程的。

因此，在POE编程中，尽量不要使用阻塞式的系统调用，否则会导致整个POE运行的阻塞。

driver: 是POE的I/O层的最低层。

现在，POE的发布版本中只有一个driver -- POE::Driver::SysRW.

它可以从文件句柄中读写数据.

filter: 它是将格式化的数据块转换成另一种格式的接口。

例如，POE::Filter::HTTPD将HTTP 1.0的请求转换成HTTP::Request对象并返回;

POE::Filter::Line将原始数据流转换成多行(就像Perl的<>操作)。

wheel: 它是处理任务的高级逻辑的可重用代码片断。

它们以POE的方式将有用的代码做了封装。

在POE中，通常使用wheel做的事情包括处理事件驱动的输入输出，易用的网络连接。

Wheel通常使用Filter和Driver来通知和发送数据。

component: 它就是一个封装好了的可重用的session，可以被别的session控制。

其它的session可以发送命令给它，也可以从它那接收事件，很像OS中的使用IPC进行进程通信。

Component的例子包括,

POE::Component::IRC, 用来创建基于POE的IRC客户端的接口;

POE::Component::HTTP, Perl中由事件驱动的用户代码。

二、POE::Wheel简介

POE::Wheel是封装好了的用来执行特定任务的事件句柄包，

它负责管理激活对应事件处理句柄的事件监测器。

在POE::Wheel创建时，它会添加匿名的事件句柄给调用它的session。

因此，当session创建wheel时，就需要处理这些新的事件。

常用的Wheel有如下:

POE::Wheel::Curses - Non-blocking input for Curses.

POE::Wheel::FollowTail - Non-blocking file and FIFO monitoring.

POE::Wheel::ListenAccept - Non-blocking server for existing sockets.

POE::Wheel::ReadLine - Non-blocking console input, with full readline support.

POE::Wheel::ReadWrite - Non-blocking stream I/O.

POE::Wheel::Run - Non-blocking process creation and management.

POE::Wheel::SocketFactory - Non-blocking socket creation, supporting most protocols and modes.

三、POE::Wheel::Run简介

是一个非阻塞的进程创建和管理器。

因为POE本身不是多线程或多进程的，所以要创建子进程以并行处理时就要用到它啦。

父进程和子进程可以通过子进程的文件句柄STDIN, STDOUT和STDERR进行通信。

在父进程中，用POE::Wheel::Run对象表示子进程，

可以使用这个对象的PID()和kill()方法来查询和管理子进程。

父进程使用put()方法发送数据到子进程STDIN,

子进程的STDOUT和STDERR将会以事件方式发送给父进程。

POE::Wheel::Run对象同样可以在子进程关闭其输出文件句柄时通知父进程。

但父进程监视子进程退出更可靠的方式是使用：

POE::Kernel的sig_child();

它会等待wheel的子进程退出并回收。

而且最好在所有的环境下都要用sig_child(),

不然，POE不会回收子进程。从而导致进程的泄漏，对于长时运行的程序来说，这是致命的。

对于这种情况，POE::Kernel在退出时会有warning提示。

POE::Wheel::Run的对象和子进程的通信，默认地是基于行的。

在程序开发时，可以通过使用POE::Filter对象来覆盖

"StdinFilter","StdoutFilter","StdioFilter"和"StderrFilter"事件句柄，

实现更多样的数据处理方式。

四、示例程序

本例是一很简单的示例程序，主要是用来说明整个开发流程。

程序实现的是用子进程打开文件，读取三行，

并在父进程中显示出这三行的内容。

闲话少说，正式开始程序:

1. 主程序

1 #!/usr/bin/perl -w

3 ###############################################################################

4 # \File

5 # test_poe_wheel_run.pl

6 # \Descript

7 # test POE::Wheel::Run

8 # \Author

9 # Hank

10 # \Created date

11 # 2013-4-25

12 ###############################################################################

13 use strict;

14 use POE qw(Wheel::Run

15 Filter::Reference);

17 my $filename = "test_file.ini";

18 my $line_num = 3;

20 our $task_pid = 1;

21 $SIG{TERM} = $SIG{INT} = sub {

22 kill KILL => $task_pid;

23 exit;

24 };

26 #

27 # Main process

28 #

29 POE::Session->create(

30 inline_states => {

31 _start => \&start_task,

32 _stop => \&handle_task_shutdown,

33 task_result => \&handle_task_result,

34 task_done => \&handle_task_done,

35 task_debug => \&handle_task_debug,

36 sig_child => \&handle_sig_child,

37 },

38 args => [$filename, $line_num],

39 );

41 $poe_kernel->run();

43 exit;

Line14,15:

导入要用的POE模块,qw()声明是Perl用来一次性加载多个POE模块的简写方式，

它和下面的代码等同:

use POE;

use POE::Wheel::Run;

use POE::Filter::Reference;

Line17,18:

定义了要读取的文件和行数，这么写是为了示例如何进行参数传递。

Line20~24:

这段代码在POE::Wheel::Run开发中很有必要，它的作用是在整个POE进程用

Ctrl+c或退出时kill掉子进程。

否则会造成子进程失去父亲，被系统的init接管。

Line29:

POE的session创建函数。

Line30~37:

向POE注册本程序要处理的状态，以及这些状态对应的状态处理句柄。

以"_"开始的"_start","_stop"是POE::Kernel默认的状态，分别用于session的启动和销毁。

sig_child注册的POE::Kernel对子进程退出后，对其回收的状态处理句柄。

其它三个状态都是自定义状态及其处理句柄。

Line38:

是将参数传递给session的启动状态对应的处理函数start_task().

POE使用了一个传递参数的特别方式:

它将数组@_封装了很多额外的参数 -- 分别是:

当前内核, session的引用, 状态名, Heap的引用，以及ARG0 ~ ARG9;

要访问它们，可以使用数组@_加下标KERNEL, SESSION, STATE, HEAP, ARG0 ~ ARG9。

这样的设计是为了最大化的提高运行速度。

所以，在POE中的参数或数据在状态处理函数间的传递有两种方式:

HEAP哈希，或ARG0~ARG9.

Line38用的就是后一种，[$filename, $line_num]对应赋值到ARG0和ARG1。

Line41~43:

启动POE::Kernel，由此便建立了一个用来探测并分派事件的主循环。整个程序就运转起来了。

且run方法只有在所有session返回之后才会停止循环。

之后，我们调用一个表示程序结束的提示符的exit系统方法来表示程序被终止。

POE轮次处理每一个事件，每次只有一个事件句柄被运行。

当事件句柄运行的时候，POE::Kernel自身也将被中断，在事件句柄返回之前，没有事件被分派。

当各个session的事件被传送到主程序事件队列后，位于队列头部的事件被首先处理，

新来的事件将被放置在队列的尾部。以此保证队列的轮次处理。

POE::Kernek的run方法在最后一个session停止之后返回。

整个主程序的执行顺序是如下:

先创建session，

session创建完成后就发送第一个事件_start;

之后启动POE的kernel。

此时事件队列中已有一个_start事件，所以进入_start事件对应的状态处理函数start_task()。

2. _start状态处理函数

44 #

45 # sub-functions

46 #

47 sub start_task {

48 my ($kernel, $heap) = @_[KERNEL, HEAP];

49 my ($fname, $lnum) = @_[ARG0..ARG1];

50 my @params = ($fname, $lnum);

52 my $task = POE::Wheel::Run->new(

53 Program => sub { task_stuff(@params) },

54 StdoutEvent => "task_result",

55 StderrEvent => "task_debug",

56 CloseEvent => "task_done",

57 );

59 $kernel->sig_child($task->PID, "sig_child");

60 $task_pid = $task->PID;

62 # Wheel events include the wheel's ID.

63 $heap->{children_by_wid}{$task->ID} = $task;

65 # Signal events include the process ID.

66 $heap->{children_by_pid}{$task->PID} = $task;

68 print("Child pid ", $task->PID," started as wheel ", $task->ID, ".\n");

69 }

Line49:

取得Line38经ARG0，ARG1传递的参数。

Line50:

将变量打包到数组，以传给子进程。

Line52~57:

创建POE::Wheel::Run对象，

并将要处理的事件映射到session的state,以事件发生时触发相应的状态处理函数。

Line53:

是指定子进程将要执行程序，子进程是以exec()方式运行.

If Program holds a scalar, its value will be executed as exec($program).

Shell metacharacters are significant, per exec(SCALAR) semantics.

If Program holds an array reference, it will executed as exec(@$program).

As per exec(ARRAY), shell metacharacters will not be significant.

If Program holds a code reference, that code will be called in the child process

Line59:

指定进程退出时用来回收的事件。

Line62~66:

将子进程的进程号和Wheel的ID以哈希的方式存储在HEAP中，以用于本session的其它状态处理函数。

3. _stop状态处理函数

71 sub handle_task_shutdown {

72 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];

73 my $task_id = $_[ARG0];

75 ## delete all wheels.

76 delete $heap->{wheel};

78 ## clear your alias

79 #$kernel->alias_remove($heap->{alias});

81 ## clear all alarms you might have set

82 #$kernel->alarm_remove_all();

84 return;

85 }

如代码所示，在session退出时进行各种资源的回收。

4. 子进程STDOUT,STDERR及进程结束事件触发的状态处理函数

87 sub handle_task_result {

88 my ($stdout_line, $wheel_id) = @_[ARG0, ARG1];

89 my $child = $_[HEAP]{children_by_wid}{$wheel_id};

91 print "pid ", $child->PID, " STDOUT: $stdout_line\n";

92 }

94 sub handle_task_debug {

95 my $result = $_[ARG0];

96 }

98 sub handle_task_done {

99 my ($kernel, $heap, $task_id) = @_[KERNEL, HEAP, ARG0];

100 delete $heap->{task}->{$task_id};

101}

Line87~92:

StdoutEvent由子进程的打印到STDOUT触发。

它带有两个参数:

ARG0: 子进程写到STDOUT的信息;

ARG1: 读取这个输出的Wheel的ID号;

Line94~96:

StderrEvent和StdoutEvent的处理方式一样，在子进程写STDERR时触发。

它带有两个参数:

ARG0: 子进程写到STDERR的信息;

ARG1: 读取这个输出的Wheel的ID号;

Line98~101:

CloseEvent在子进程关闭它最后一次打开的文件句柄时触发，

但它不是子进程结束时的信号。对于就种情况使用sig_child()来处理。

在CloseEvent发生之后，就不可能再触发ErrorEvent或StdoutEvent。

它带有一个参数:

ARG0: Wheel的ID号,可以用来在一个session管理多个子进程时分开处理。

5. 子进程结束时session对子进程资源的回收

103sub handle_sig_child {

104 my ($heap, $sig, $pid, $exit_val) = @_[HEAP, ARG0, ARG1, ARG2];

105 my $child = delete $heap->{children_by_pid}{$pid};

106

107 return unless defined $child;

108 delete $heap->{children_by_wid}{$child->ID};

109 print "PID $$: Child-pid $pid exited\n";

110}

sig_child()是在特定子进程PROCESS_ID退出后，触发相应事件以进行处理的方便方式。

它带有多个参数:

my ($heap, $sig, $pid, $exit_val) = @_[HEAP, ARG0, ARG1, ARG2];

一个session可以注册多个sig_child()句柄，但是每个子进程对应的只有一个。

且它不会返回任何有意义的值。

6. 子进程任务执行程序体

112#

113# task instance

114#

115sub task_stuff {

116 my ($file, $line) = @_[0..1];

117

118 if ( !open(TASKFILE, "$file")){

119 print STDERR "Cann't open the file $file\n";

120 exit;

121 }

122

123 my $index = 0;

124 foreach my $task (<TASKFILE>){

125 print "$task";

126 $index++;

127 last if ($index == $line);

128 }

129 close (TASKFILE);

130}

这部分就和普通编程别无二致了:

获取参数，打开文件，读取三行，关闭文件。

只是Line119,line125不会在子进程中直接打印输出，

它们分别触发StdoutEvent 和StderrEvent事件，

从而调用相应的状态处理函数handle_task_result()和handle_task_debug()。

更多的事件和状态处理函数的解析可以看官方的文档:

https://metacpan.org/module/POE::Wheel

https://metacpan.org/module/POE::Kernel

《象》曰：天行健，君子以自强不息。

【白话】《象辞》说：天道运行周而复始，永无止息，谁也不能阻挡，君子应效法天道，自立自强，不停地奋斗下去。

POE::Wheel::Run示例详解

继续阅读

网络交换机怎么连接硬盘录像机、网络交换机怎么连接摄像头

树莓派CM4_PoE_SSD扩展板硬盘测速

POE交换机隐藏指标是什么？

POE状态机入门与进阶

POE接口电路设计

PoE交换机不供电了该怎么办？

H3C交换机POE固件版本升级流程H3C交换机POE固件版本升级流程

交换机POE watchdog功能测试

POE交换机产品如何设计防雷保护？

为什么要用隔离型POE

POE干货

POE原理与配置

POE POH等供电

POE网络变压器：标准POE的安全特性　标准POE的安全特性

路由器开发相关知识总结 —— POE供电设备原理详解