Php on 勇气

使用pack/unpack打包/解包二进制数据

Wed, 14 Aug 2019 14:24:47 +0800

web开发中，通常使用的API接口协议都是基于HTTP(S)的文本协议，比如JSON或XML。这对于跨编程语言的通信已经没有问题了，但有时候会采用二进制的数据来通信，以便获得更高的性能，比如Apache Thrift、gRPC/Protocol Buffer。各个编程语言都有对应的pack/unpack函数，PHP可以使用pack/unpack函数对数据进行二进制编码/解码，它与Perl的pack函数比较类似。
PHP的pack函数至少需要两个参数，第一个参数为打包格式，第二个参数开始为打包的数据。每个格式化字符后面可以跟字节长度，对应打包一个数据；也可以用*自动匹配所有后面的数据，具体的格式化字符可以参考pack函数页面。来看下面的例子pack.php

<?php
declare(strict_types=1);

$data = array(
 array(
 'title' => 'C Programming',
 'author' => 'Nuha Ali',
 'subject' => 'C Programming Tutorial',
 'book_id' => 6495407
 ),
 array(
 'title' => 'Telecom Billing',
 'author' => 'Zara Ali',
 'subject' => 'Telecom Billing Tutorial',
 'book_id' => 6495700
 ),
 array(
 'title' => 'PHP Programinng',
 'author' => 'Channing Huang',
 'subject' => 'PHP Programing Tutorial',
 'book_id' => 6495701
 )
);
$fp = \fopen("example","wb");
foreach ($data as $row) {
 $bin = \pack('Z50Z50Z100i', ...\array_values($row));
 \fwrite($fp, $bin);
}
\fclose($fp);

这里有个books数组，每个book包含4个数据：title、author、subject、bookid，对应的格式化是Z50、Z50、Z100、i。Z50意思是打包成50的字节的二进制数据，剩余部分使用NULL填充，这个跟使用a50是类似的，如果要用空格填充则格式化字符应该是A50。Z100类似Z50，不过字节长度为100。i的意思是打包成有符号的整型对应C里面的signed integer，占4个字节。所以每个book应该占50+50+100+4=204字节，3个book总占用612字节。查看一下

[vagrant@localhost bin]$ ls -la | grep example
-rw-r--r--. 1 vagrant vagrant 612 Aug 14 02:22 example

使用xxd查看它的二进制内容，确定是使用NULL填充不足部分

[vagrant@localhost bin]$ xxd -b example 
0000000: 01000011 00100000 01010000 01110010 01101111 01100111 C Prog
0000006: 01110010 01100001 01101101 01101101 01101001 01101110 rammin
000000c: 01100111 00000000 00000000 00000000 00000000 00000000 g.....
0000012: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000018: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000001e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000024: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000002a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000030: 00000000 00000000 01001110 01110101 01101000 01100001 ..Nuha
0000036: 00100000 01000001 01101100 01101001 00000000 00000000 Ali..
000003c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000042: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000048: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000004e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000054: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000005a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000060: 00000000 00000000 00000000 00000000 01000011 00100000 ....C 
0000066: 01010000 01110010 01101111 01100111 01110010 01100001 Progra
000006c: 01101101 01101101 01101001 01101110 01100111 00100000 mming 
0000072: 01010100 01110101 01110100 01101111 01110010 01101001 Tutori
0000078: 01100001 01101100 00000000 00000000 00000000 00000000 al....
000007e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000084: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000008a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000090: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000096: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000009c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000a2: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000a8: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000ae: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000b4: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000ba: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000c0: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000c6: 00000000 00000000 10101111 00011100 01100011 00000000 ....c.
00000cc: 01010100 01100101 01101100 01100101 01100011 01101111 Teleco
00000d2: 01101101 00100000 01000010 01101001 01101100 01101100 m Bill
00000d8: 01101001 01101110 01100111 00000000 00000000 00000000 ing...
00000de: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000e4: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000ea: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000f0: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000f6: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00000fc: 00000000 00000000 01011010 01100001 01110010 01100001 ..Zara
0000102: 00100000 01000001 01101100 01101001 00000000 00000000 Ali..
0000108: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000010e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000114: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000011a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000120: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000126: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000012c: 00000000 00000000 00000000 00000000 01010100 01100101 ....Te
0000132: 01101100 01100101 01100011 01101111 01101101 00100000 lecom 
0000138: 01000010 01101001 01101100 01101100 01101001 01101110 Billin
000013e: 01100111 00100000 01010100 01110101 01110100 01101111 g Tuto
0000144: 01110010 01101001 01100001 01101100 00000000 00000000 rial..
000014a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000150: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000156: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000015c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000162: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000168: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000016e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000174: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000017a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000180: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000186: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000018c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000192: 00000000 00000000 11010100 00011101 01100011 00000000 ....c.
0000198: 01010000 01001000 01010000 00100000 01010000 01110010 PHP Pr
000019e: 01101111 01100111 01110010 01100001 01101101 01101001 ogrami
00001a4: 01101110 01101110 01100111 00000000 00000000 00000000 nng...
00001aa: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001b0: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001b6: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001bc: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001c2: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001c8: 00000000 00000000 01000011 01101000 01100001 01101110 ..Chan
00001ce: 01101110 01101001 01101110 01100111 00100000 01001000 ning H
00001d4: 01110101 01100001 01101110 01100111 00000000 00000000 uang..
00001da: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001e0: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001e6: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001ec: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001f2: 00000000 00000000 00000000 00000000 00000000 00000000 ......
00001f8: 00000000 00000000 00000000 00000000 01010000 01001000 ....PH
00001fe: 01010000 00100000 01010000 01110010 01101111 01100111 P Prog
0000204: 01110010 01100001 01101101 01101001 01101110 01100111 raming
000020a: 00100000 01010100 01110101 01110100 01101111 01110010 Tutor
0000210: 01101001 01100001 01101100 00000000 00000000 00000000 ial...
0000216: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000021c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000222: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000228: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000022e: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000234: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000023a: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000240: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000246: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000024c: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000252: 00000000 00000000 00000000 00000000 00000000 00000000 ......
0000258: 00000000 00000000 00000000 00000000 00000000 00000000 ......
000025e: 00000000 00000000 11010101 00011101 01100011 00000000 ....c.

PHP的unpack函数有三个参数，第一个为解包的格式化字符，第二个为打包过的数据，第三个为起始偏移量。解包后返回一个关联数组，可以在解包的格式化字符串后面跟对应的key。

<?php
declare(strict_types=1);

$fp = \fopen("example","rb");
while (!\feof($fp)) {
 $data = \fread($fp,204);
 if($data) {
 $arr = \unpack("Z50title/Z50author/Z100subject/ibook_id",$data);
 foreach ($arr as $key => $value) {
 echo $key. "->" . $value.PHP_EOL;
 }
 echo PHP_EOL;
 }
}
\fclose($fp);

这样就可以读取对应的二进制文件，并正确解析出来。
不同的编程语言都可以对二进制文件进行读写。比如C语言里面打包上面的数据

#include<stdio.h>
#include<stdlib.h>

struct book {
 char title[50];
 char author[50];
 char subject[100];
 int id;
};
 
 int main()
 {
 FILE *fp;
 struct book books[3] = {
 {"C Programming", "Nuha Ali", "C Programming Tutorial", 6495407},
 {"Telecom Billing", "Zara Ali", "Telecom Billing Tutorial", 6495700},
 {"PHP Programinng", "Channing Huang", "PHP Programing Tutorial", 6495701}
 };
 fp = fopen("newbook", "wb");
 
 if(fp == NULL)
 {
 printf("Error opening file\n");
 exit(1);
 }
 printf("sizeof books %10lu\n", sizeof(books));
 printf("sizeof book struct %10lu\n", sizeof(struct book));
 printf("sizeof book1 title %10lu\n", sizeof(books[0].title));
 printf("sizeof book1 author %10lu\n", sizeof(books[0].author));
 printf("sizeof book1 subject %10lu\n", sizeof(books[0].subject));
 printf("sizeof book1 id %10lu\n", sizeof(books[0].id));
 fwrite(books, sizeof(books), 1, fp);
 fclose(fp);
 return 0;
 }

编译运行一下

[vagrant@localhost bin]$ gcc -o pack pack.c
[vagrant@localhost bin]$ ./pack
sizeof books 612
sizeof book struct 204
sizeof book1 title 50
sizeof book1 author 50
sizeof book1 subject 100
sizeof book1 id 4
[vagrant@localhost bin]$ ls -lah | grep newbook
-rw-r--r--. 1 vagrant vagrant 612 Aug 14 02:50 newbook

可以看到生成的文件大小与上面的一样，使用xxd查看的内容也跟上面的一样，并且可以使用unpak.php解析。类似的也可以用C来解析PHP打包的二进制数据

#include<stdio.h>
#include<stdlib.h>

struct book {
 char title[50];
 char author[50];
 char subject[100];
 int id;
};
 
 int main()
 {
 int i;
 FILE *fp;
 struct book Book;
 fp = fopen("example", "rb");
 
 if(fp == NULL)
 {
 printf("Error opening file\n");
 exit(1);
 }
 for (i=0;i<3; i++)
 {
 fread(&Book,sizeof(struct book),1,fp);
 printf( "Book title : %s\n", Book.title);
 printf( "Book author : %s\n", Book.author);
 printf( "Book subject : %s\n", Book.subject);
 printf( "Book book_id : %d\n", Book.id);
 }
 fclose(fp);
 return 0;
 }

编译运行一下

[vagrant@localhost bin]$ gcc -o unpack unpack.c
[vagrant@localhost bin]$ ./unpack
Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700
Book title : PHP Programinng
Book author : Channing Huang
Book subject : PHP Programing Tutorial
Book book_id : 6495701

这里使用C的struct定义打包解包数据，这里面有两个问题：字节对齐和NULL填充。字节对齐会导致生成的二进制文件大小与结构体里面定义的不一样，比如将title改为40个字节，整个book预计占用194字节，实际占用196字节（4的倍数），编译器自动填充了2个字节到title后面。所以要注意数据结构体的设计，避免过多对齐浪费。C语言的字符串其实是字符数组加上NUL结束符（\0）,像上面那样初始化字符串是编译器默认填充的是NUL，但如果声明时没有初始化而是在后面赋值，比如strcpy，则可能在NUL后面填充非NUL值，导致在PHP解析出这些不必要的字符，显示不准确，这也是为什么在PHP里面解析时我们使用Z而不是A解析符的原因，它在碰到NUL便返回，不管后面填充的内容了。可以使用memset手动填充不足部分为’\0’，这样子就可以保证剩余部分全为NULL了。
对于unsigned short，unsigned long，float，double还有大端序、小端序，字节顺序可以参考这里。通常网络设备传输的字节序为大端序，而大部分CPU（x86）处理的字节序为小端序。这里只要通信双方沟通统一使用大端序或小端序即可，不需要关心传输过程中的自动转换。比如在PHP里面发送一个数字（4字节）和8个字符（8字节）

<?php
declare(strict_types=1);

$host = "127.0.0.1";
$port = 9872;

$socket = \socket_create(AF_INET, SOCK_STREAM, SOL_TCP)
 or die("Unable to create socket\n");

@\socket_connect($socket, $host, $port) or die("Connect error.\n");

if ($err = \socket_last_error($socket))
{

 \socket_close($socket);
 die(\socket_strerror($err) . "\n");
}

$binarydata = \pack("Na8", "256", "Channing");
echo \bin2hex($binarydata).PHP_EOL;
$len = \socket_write ($socket , $binarydata, strlen($binarydata));
\socket_close($socket);

PHP里面数字的格式化字符是N，即采用大端序32位编码。在GO里面接收，使用大端序解析位数字

package main

import (
	"fmt"
	"net"
	"encoding/binary"
)

const BUF_SIZE = 12

func handleConnection(conn net.Conn) {
	defer conn.Close()
	buf := make([]byte, BUF_SIZE)
	n, err := conn.Read(buf)

	if err != nil {
		fmt.Printf("err: %v\n", err)
		return
	}

	//fmt.Printf("\nreceive：%d bytes，data：%x, %s\n", n, buf[:4], buf[4:])
	fmt.Printf("\nreceive：%d bytes，data：%d, %s\n", n, binary.BigEndian.Uint32(buf[:4]), buf[4:])
}

func main() {
	ln, err := net.Listen("tcp", ":9872")

	if err != nil {
		fmt.Printf("error: %v\n", err)
		return
	}

	for {
		conn, err := ln.Accept()
		if err != nil {
			continue
		}
		go handleConnection(conn)
	}
}

运行recieve.go 和 send.php，可以正常收发

[root@localhost bin]$ php send.php
000001004368616e6e696e67


[root@localhost bin]$ go run receive.go 

receive：12 bytes，data：256, Channing

如果在PHP里面使用了不匹配的格式化符号，比如i或者n，GO里面将解析错误。这里也可以采用小端序编码和解析。
pack后的二进制数据可以使用bin2hex转换为16进制查看，使用chr转换单个字节为可读性字符。
通常我们读写的是文本文件，这里读写的是二进制文件，文本文件到二进制文件有个编码过程，比如ASCII、UTF-8。其实文本文件，图片文件，都是二进制文件，都可以使用xxd查看，只不过特定软件能够解析（解码）对应的二进制字节数据。使用xxd查看时，它只能现显示ASCII可打印字符，不能显示的用点号表示。

参考链接：
Apache Thrift – 可伸缩的跨语言服务开发框架
 Google Protocol Buffer 的使用和原理
 高效的数据压缩编码方式 Protobuf
PHP: 深入pack/unpack
C Programming Files I/O
Unpacking binary data in PHP
大端和小端（Big endian and Little endian）
PHP RPC开发之Thrift

Jupyter Notebook

Mon, 03 Jun 2019 15:30:07 +0800

对于编程初学者，如果有一个开箱即用的环境，比如web页面，就可以进行编程交互，那是极友好。有时候我们想在远程服务器上执行一些脚本，输出一些结果，比如科学计算；有时候又想在服务器上执行一些命令但又不能直接登录服务器，如果能够在web界面上操作或作为跳板机，那也是极友好的。Jupyter Notebook是基于IPython的一个基于web交互执行的在线环境，支持Python，也支持其他编程语言，比如Julia和R。所创建Notebook文档可以自动保存执行过的代码、结果，方便进行回放。
Jupyter Notebok的安装很方便，可以使用Anaconda来安装，或者手动安装。Python3下手动安装，

pip3 install jupyter
export PATH=$PATH:/usr/local/python3/bin

查看一下

[root@localhost local]# pip3 show jupyter
Name: jupyter
Version: 1.0.0
Summary: Jupyter metapackage. Install all the Jupyter components in one go.
Home-page: http://jupyter.org
Author: Jupyter Development Team
Author-email: jupyter@googlegroups.org
License: BSD
Location: /usr/local/python3/lib/python3.7/site-packages
Requires: jupyter-console, notebook, ipywidgets, nbconvert, qtconsole, ipykernel
Required-by:

如果直接运行jupyter notebook，那么会生成一个本地可以访问的带token的url，每次都不一样，不是很方便。设置密码，以便登录

[root@localhost opt]# jupyter notebook password
Enter password: 
Verify password: 
[NotebookPasswordApp] Wrote hashed password to /root/.jupyter/jupyter_notebook_config.json
[root@localhost bin]# cat /root/.jupyter/jupyter_notebook_config.json 
{
 "NotebookApp": {
 "password": "sha1:e04153005102:961b12eef91987a06b497f915fc3f18c62d8f714"
 }

由于是在虚拟机里面，我们并不需要Jupyter自动打开浏览器，但需要监听来自任意IP的请求，指定端口9030。这里使用root用户运行Jupyter，默认是不允许的：

[root@localhost opt]# jupyter notebook --no-browser --allow-root --ip 0.0.0.0 --port 9030
[I 02:13:44.320 NotebookApp] Serving notebooks from local directory: /opt
[I 02:13:44.320 NotebookApp] The Jupyter Notebook is running at:
[I 02:13:44.320 NotebookApp] http://(localhost.localdomain or 127.0.0.1):9030/
[I 02:13:44.320 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[I 02:13:59.664 NotebookApp] 302 GET / (192.168.33.1) 1.22ms
[I 02:14:23.597 NotebookApp] Kernel started: 7ad63717-7a65-4dec-9d5a-9af654c28f75
[I 02:14:25.204 NotebookApp] Adapting to protocol v5.1 for kernel 7ad63717-7a65-4dec-9d5a-9af654c28f75
[I 02:14:37.350 NotebookApp] Starting buffering for 7ad63717-7a65-4dec-9d5a-9af654c28f75:ea68853b742c40f8bcf8745529ea95de
[I 02:14:43.735 NotebookApp] Kernel started: 5b569c8d-6936-4bd2-9674-0317c46948f6
[I 02:14:44.124 NotebookApp] Adapting to protocol v5.0 for kernel 5b569c8d-6936-4bd2-9674-0317c46948f6
[2019-06-03 02:14:43] kernel.DEBUG: Connection settings {"processId":6751,"connSettings":{"shell_port":39990,"iopub_port":48184,"stdin_port":40113,"control_port":43426,"hb_port":49075,"ip":"127.0.0.1","key":"d5f89bba-890ecf15e6b20718411170ad","transport":"tcp","signature_scheme":"hmac-sha256","kernel_name":"jupyter-php"},"connUris":{"stdin":"tcp://127.0.0.1:40113","control":"tcp://127.0.0.1:43426","hb":"tcp://127.0.0.1:49075","shell":"tcp://127.0.0.1:39990","iopub":"tcp://127.0.0.1:48184"}} []
[2019-06-03 02:14:44] KernelCore.DEBUG: Initialized sockets {"processId":6751} []

然后打开浏览器，访问http://192.168.33.70:9030，输入账号密码，就可以在web里面运行Python了

Jupyter默认带了SQL扩展，使用ipython-sql来执行，只需要安装对应的驱动，这里使用PyMySQL

python3 -m pip install PyMySQL

然后在Web里面执行就可以了

Jupyter还有其他扩展，参考这里。
除了可以执行Python和SQL，Jupyter Notebook也可以支持其他语言，在这里列出了。通常执行方式是通过Bash执行，或者通过ZeroMQ来通信，参考这里实现。一个Jupyter的kernal将需要监听以下几个socket：

Shell：执行命令
IOPub：推送执行结果
Stdin：接收输入
Control：接收控制命令，比如关闭、终端
Heartbeat：心跳检测

这个思路也可以用来做IOT设备的远程监控，交互执行。
这里安装一下PHP 7这个kernel，作者甚至还提供了installer，但是首先要安装ZeroMQ以便与Jupyter服务通信

yum install php-pecl-zmq
wget https://litipk.github.io/Jupyter-PHP-Installer/dist/jupyter-php-installer.phar
./jupyter-php-installer.phar install

查看安装文件

[root@localhost opt]# ls -la /usr/local/share/jupyter/kernels/
total 0
drwxr-xr-x. 4 root root 34 May 10 06:10 .
drwxr-xr-x. 3 root root 20 May 9 07:30 ..
drwxr-xr-x. 2 root root 24 May 9 07:30 jupyter-php
drwxr-xr-x. 2 root root 40 May 10 06:10 lgo

[root@localhost opt]# cat /usr/local/share/jupyter/kernels/jupyter-php/kernel.json 
{"argv":["php","\/opt\/jupyter-php\/pkgs\/vendor\/litipk\/jupyter-php\/src\/kernel.php","{connection_file}"],"display_name":"PHP","language":"php","env":{}}

这个扩展使用了react/zmq来监听Jupyter请求，使用psysh来交互执行PHP代码。

如果想要更改Jupyter的web模板，可以在以下目录找到

[root@localhost vagrant]# ls -la /usr/local/python3/lib/python3.7/site-packages/notebook/templates
total 92
drwxr-xr-x. 2 root root 4096 May 9 06:33 .
drwxr-xr-x. 19 root root 4096 May 9 06:33 ..
-rw-r--r--. 1 root root 147 May 9 06:33 404.html
-rw-r--r--. 1 root root 499 May 9 06:33 browser-open.html
-rw-r--r--. 1 root root 4258 May 9 06:33 edit.html
-rw-r--r--. 1 root root 856 May 9 06:33 error.html
-rw-r--r--. 1 root root 4256 May 9 06:33 login.html
-rw-r--r--. 1 root root 1179 May 9 06:33 logout.html
-rw-r--r--. 1 root root 23162 May 9 06:33 notebook.html
-rw-r--r--. 1 root root 6559 May 9 06:33 page.html
-rw-r--r--. 1 root root 1089 May 9 06:33 terminal.html
-rw-r--r--. 1 root root 12130 May 9 06:33 tree.html
-rw-r--r--. 1 root root 544 May 9 06:33 view.html

Jupyter Notebook Web前端采用WebSocket与服务器交互，服务器接收消息并转发给对应的kernel执行或控制，并将结果推送给前端。Jupyter Notebook也可以直接打开Terminal，在远程服务器上执行命令。注意这里的用户就是刚才运行jupyter的用户

许多web terminal也都是采用WebSocket来做交互，比如xterm.js，webtty。
Juypter Notebook适合单用户（单机）使用，如果提供多用户使用（比如教学），可以使用Jupyter Hub，可以使用docker快捷部署。

参考链接：
Jupyter Notebook Extensions
Jupyter – How do I decide which packages I need?
PsySH——PHP交互式控制台
 Jupyter项目
 WebSocket 教程

Let’s encrypt

Sun, 11 Feb 2018 15:21:18 +0800

最近域名主机双双到期了，原来的服务商建议域名迁出，于是转移到了Godaddy，过程很顺利。主机迁到了linode，一个是因为它便宜，另一个是因为想给自己的网站加个SSL证书。
首先是服务器环境Apache, PHP, MaraiDB(MySQL)的配置。 linode 创建主机很简单，点点就好了，然后可以去启动机器，设置SSH访问。

yum update
yum install httpd php php-cli php-mbstring php-pdo php-mysql php-gd php-tidy

启动Apache

systemctl start httpd.service
systemctl enable httpd.service

然后直接访问你的服务器ip，可以看到默认的欢迎界面

ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
curl 1.139.x.x

CentOS 7目前默认不提供Mysql Server，而是Mariadb。MySQL的命令行仍然可以使用并兼容， PHP仍然可以使用PDO及MySQL扩展访问它。

yum install mariadb-server mariadb
systemctl start mariadb

然后设置管理员密码及安全设置

mysql_secure_installation

开机启动Mariadb服务

systemctl enable mariadb.service

可以在/var/www/html目录下创建一个测试脚本来验证安装情况

<?php
phpinfo();

WordPress则是从原本的数据库全部导出，文件全部打包回来。
在Linode上创建对应的数据库，用户及导入脚本

MariaDB [(none)]> CREATE database courages_wordpress;

MariaDB [(none)]> CREATE USER courages_wp IDENTIFIED BY '*************';

MariaDB [(none)]> grant all privileges on courages_wordpress.* to courages_wp@localhost identified by '*************';

导入数据库

mysql -uroot -p courages_wordpress < /tmp/wordpress.sql

将文件解压并复制到/var/www/html目录

tar -xzvf backup.tar.gz
cp -R backup/public_html/* /var/www/html/*
chown -R apache:apache /var/www/html

更改Apache设置AllowOverride 为all，以便支持WordPress的链接重定向。

vim /etc/httpd/conf/httpd.conf

<Directory "/var/www/html">
 #
 # Possible values for the Options directive are "None", "All",
 # or any combination of:
 # Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
 #
 # Note that "MultiViews" must be named *explicitly* --- "Options All"
 # doesn't give it to you.
 #
 # The Options directive is both complicated and important. Please see
 # http://httpd.apache.org/docs/2.4/mod/core.html#options
 # for more information.
 #
 Options Indexes FollowSymLinks

 #
 # AllowOverride controls what directives may be placed in .htaccess files.
 # It can be "All", "None", or any combination of the keywords:
 # Options FileInfo AuthConfig Limit
 #
 AllowOverride All

 #
 # Controls who can get stuff from this server.
 #
 Require all granted
</Directory>

重启Apache

systemctl restart httpd.service

在linode的DNS manager那里新增一个新的domain，在服务器列表里面选中对应的服务器就可以了，然后就可以看到对应的域名解析信息。
域名转移会要求一个key，从原注册商那里解锁并获得，在Godday输入Key后，它会发邮件与你确认，然后将DNS域名服务器改为linode的域名服务器就好了。

Let’s Encrypt提供免费90天的SSL证书，如果证书到期了就需要再次更新下。如果你有shell权限，它推荐使用Cerbot来安装和更新证书。CentOS 7 + Apache的安装非常简单。首先安装EPEL源，要不然找不到对应的安装包

yum install epel-release
yum install certbot-apache
certbot --authenticator webroot --installer apache

设置一下域名，网站目录及域名重定向

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator webroot, Installer apache
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): <email@example.com>
Starting new HTTPS connection (1): acme-v01.api.letsencrypt.org

-------------------------------------------------------------------------------
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v01.api.letsencrypt.org/directory
-------------------------------------------------------------------------------
(A)gree/(C)ancel: A

-------------------------------------------------------------------------------
Would you be willing to share your email address with the Electronic Frontier
Foundation, a founding partner of the Let's Encrypt project and the non-profit
organization that develops Certbot? We'd like to send you email about EFF and
our work to encrypt the web, protect its users and defend digital rights.
-------------------------------------------------------------------------------
(Y)es/(N)o: Y
Starting new HTTPS connection (1): supporters.eff.org
No names were found in your configuration files. Please enter in your domain
name(s) (comma and/or space separated) (Enter 'c' to cancel): courages.us
Obtaining a new certificate
Performing the following challenges:
http-01 challenge for courages.us
Input the webroot for courages.us: (Enter 'c' to cancel): /var/www/html
Waiting for verification...
Cleaning up challenges

We were unable to find a vhost with a ServerName or Address of courages.us.
Which virtual host would you like to choose?
(note: conf files with multiple vhosts are not yet supported)
-------------------------------------------------------------------------------
1: ssl.conf | | HTTPS | Enabled
-------------------------------------------------------------------------------
Press 1 [enter] to confirm the selection (press 'c' to cancel): 1
Deploying Certificate for courages.us to VirtualHost /etc/httpd/conf.d/ssl.conf

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
-------------------------------------------------------------------------------
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Created redirect file: le-redirect-courages.us.conf
Rollback checkpoint is empty (no changes made?)

-------------------------------------------------------------------------------
Congratulations! You have successfully enabled https://courages.us

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=courages.us
-------------------------------------------------------------------------------

在浏览器访问一下域名即有小绿钥匙。可以在/etc/httpd/conf.d/ssl.conf查看相应的SSL证书配置

<VirtualHost _default_:443>
ServerName courages.us
SSLCertificateFile /etc/letsencrypt/live/courages.us/cert.pem
SSLCertificateKeyFile /etc/letsencrypt/live/courages.us/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf
SSLCertificateChainFile /etc/letsencrypt/live/courages.us/chain.pem
</VirtualHost>

由于证书在90天后即将失效，可以加入crontab自动更新

certbot renew --dry-run
crontab -e

0 0,12 * * * python -c 'import random; import time; time.sleep(random.random() * 3600)' && certbot renew

另外一种更新证书的方法是使用acme.sh，不依赖python，同样支持DNS验证，并且还可以获取其他CA颁发的证书，比如ZeroSSL。
安装acme。sh脚本非常简单

➜ ~ curl https://get.acme.sh | sh -s email=llitllie@163.com
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 1032 0 1032 0 0 608 0 --:--:-- 0:00:01 --:--:-- 608
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 216k 100 216k 0 0 104k 0 0:00:02 0:00:02 --:--:-- 104k
[2023年 04月 07日 星期五 22:11:22 CST] Installing from online archive.
[2023年 04月 07日 星期五 22:11:22 CST] Downloading https://github.com/acmesh-official/acme.sh/archive/master.tar.gz
[2023年 04月 07日 星期五 22:11:25 CST] Extracting master.tar.gz
[2023年 04月 07日 星期五 22:11:26 CST] It is recommended to install socat first.
[2023年 04月 07日 星期五 22:11:26 CST] We use socat for standalone server if you use standalone mode.
[2023年 04月 07日 星期五 22:11:26 CST] If you don't use standalone mode, just ignore this warning.
[2023年 04月 07日 星期五 22:11:26 CST] Installing to /root/.acme.sh
[2023年 04月 07日 星期五 22:11:26 CST] Installed to /root/.acme.sh/acme.sh
[2023年 04月 07日 星期五 22:11:26 CST] Installing alias to '/root/.zshrc'
[2023年 04月 07日 星期五 22:11:26 CST] OK, Close and reopen your terminal to start using acme.sh
[2023年 04月 07日 星期五 22:11:26 CST] Installing alias to '/root/.cshrc'
[2023年 04月 07日 星期五 22:11:26 CST] Installing alias to '/root/.tcshrc'
[2023年 04月 07日 星期五 22:11:26 CST] Installing cron job
[2023年 04月 07日 星期五 22:11:26 CST] Good, bash is found, so change the shebang to use bash as preferred.
[2023年 04月 07日 星期五 22:11:28 CST] OK
[2023年 04月 07日 星期五 22:11:28 CST] Install success!

这里采用DNS验证获取证书，设置一下DNS厂商信息，比如DNSPOD，默认获取ZeroSSL证书，可以通过–server letsencrypt切换

➜ ~ export DP_Id="95731"
➜ ~ export DP_Key="***"
➜ ~ acme.sh --issue --dns dns_dp -d example.com -d "*.example.com"
[2023年 04月 07日 星期五 22:14:24 CST] Using CA: https://acme.zerossl.com/v2/DV90
[2023年 04月 07日 星期五 22:14:24 CST] Create account key ok.
[2023年 04月 07日 星期五 22:14:24 CST] No EAB credentials found for ZeroSSL, let's get one
[2023年 04月 07日 星期五 22:14:29 CST] Registering account: https://acme.zerossl.com/v2/DV90
[2023年 04月 07日 星期五 22:14:38 CST] Registered
[2023年 04月 07日 星期五 22:14:38 CST] ACCOUNT_THUMBPRINT='AY5noJZbSullM7fVQOnluxQJmWiiKJHl0vzVsYwwGsg'
[2023年 04月 07日 星期五 22:14:38 CST] Creating domain key
[2023年 04月 07日 星期五 22:14:38 CST] The domain key is here: /root/.acme.sh/example.com_ecc/example.com.key
[2023年 04月 07日 星期五 22:14:38 CST] Multi domain='DNS:example.com
[2023年 04月 07日 星期五 22:14:39 CST] Getting domain auth token for each domain
[2023年 04月 07日 星期五 22:14:56 CST] Getting webroot for domain='example.com'
[2023年 04月 07日 星期五 22:14:56 CST] Getting webroot for domain='*.example.com'
[2023年 04月 07日 星期五 22:14:56 CST] Adding txt value: q-pQccpOPbYbC4h_veQTSvj2OgUpgg9kBUFpms9fa9k for domain: _acme-challenge.example.com
[2023年 04月 07日 星期五 22:14:57 CST] Adding record
[2023年 04月 07日 星期五 22:14:57 CST] The txt record is added: Success.
[2023年 04月 07日 星期五 22:15:01 CST] Let's check each DNS record now. Sleep 20 seconds first.
[2023年 04月 07日 星期五 22:15:23 CST] You can use '--dnssleep' to disable public dns checks.
[2023年 04月 07日 星期五 22:15:23 CST] See: https://github.com/acmesh-official/acme.sh/wiki/dnscheck
[2023年 04月 07日 星期五 22:15:23 CST] Checking example.com for _acme-challenge.example.com
[2023年 04月 07日 星期五 22:15:23 CST] Please refer to https://curl.haxx.se/libcurl/c/libcurl-errors.html for error code: 35
[2023年 04月 07日 星期五 22:15:27 CST] Domain example.com '_acme-challenge.example.com' success.
[2023年 04月 07日 星期五 22:15:34 CST] All success, let's return
[2023年 04月 07日 星期五 22:15:34 CST] Verifying: example.com
[2023年 04月 07日 星期五 22:15:46 CST] Processing, The CA is processing your order, please just wait. (1/30)
[2023年 04月 07日 星期五 22:15:51 CST] Success
[2023年 04月 07日 星期五 22:15:51 CST] Verifying: *.example.com
[2023年 04月 07日 星期五 22:15:55 CST] Processing, The CA is processing your order, please just wait. (1/30)
[2023年 04月 07日 星期五 22:16:28 CST] Success
[2023年 04月 07日 星期五 22:16:28 CST] Removing DNS records.
[2023年 04月 07日 星期五 22:16:28 CST] Removing txt: q-pQccpOPbYbC4h_veQTSvj2OgUpgg9kBUFpms9fa9k for domain: _acme-challenge.example.com
[2023年 04月 07日 星期五 22:16:30 CST] Removed: Success
[2023年 04月 07日 星期五 22:16:34 CST] Verify finished, start to sign.
[2023年 04月 07日 星期五 22:16:35 CST] Lets finalize the order.
[2023年 04月 07日 星期五 22:16:40 CST] Order status is processing, lets sleep and retry.
[2023年 04月 07日 星期五 22:16:40 CST] Retry after: 15
[2023年 04月 07日 星期五 22:17:00 CST] Downloading cert.
[2023年 04月 07日 星期五 22:17:00 CST] Le_LinkCert='https://acme.zerossl.com/v2/DV90/cert/pcAU9PLEoObR7xYPTb9x7w'
[2023年 04月 07日 星期五 22:17:03 CST] Cert success.
-----BEGIN CERTIFICATE-----
MIIELzCCA7agAwIBAgIRAOO4Gyu...
QRwR2SSrAlEIeJXua7aYyyEEJQ==
-----END CERTIFICATE-----
[2023年 04月 07日 星期五 22:17:03 CST] Your cert is in: /root/.acme.sh/example.com_ecc/example.com.cer
[2023年 04月 07日 星期五 22:17:03 CST] Your cert key is in: /root/.acme.sh/example.com_ecc/example.com.key
[2023年 04月 07日 星期五 22:17:03 CST] The intermediate CA cert is in: /root/.acme.sh/example.com_ecc/ca.cer
[2023年 04月 07日 星期五 22:17:03 CST] And the full chain certs is there: /root/.acme.sh/example.com_ecc/fullchain.cer

最后安装证书

➜ ~ acme.sh --install-cert -d example.com -d "*.example.com"--key-file /etc/letsencrypt/live/example.com/privkey.pem --fullchain-file /etc/letsencrypt/live/example.com/chain.pem --reloadcmd "systemctl restart nginx"
[2023年 04月 07日 星期五 23:00:13 CST] The domain 'example.com' seems to have a ECC cert already, lets use ecc cert.
[2023年 04月 07日 星期五 23:00:13 CST] Installing key to: /etc/letsencrypt/live/example.com/privkey.pem
[2023年 04月 07日 星期五 23:00:13 CST] Installing full chain to: /etc/letsencrypt/live/example.com/chain.pem
[2023年 04月 07日 星期五 23:00:13 CST] Run reload cmd: systemctl restart nginx
[2023年 04月 07日 星期五 23:00:13 CST] Reload success

以后就可以自动更新了

➜ ~ crontab -l | grep acme 
26 0 * * * "/root/.acme.sh"/acme.sh --cron --home "/root/.acme.sh" > /dev/null

最近登录后台发现WordPress提示升级到PHP 7.3，按照它的指示

使用UpdraftPlus备份网站和数据库，支持Google Drive, Dropbox
使用PHP Compatibility Checker检测代码及扩展是否支持升级到PHP 7.3

在CentOS 7上升级PHP5.4 到PHP 7.3很简单：
首先安装Remi和EPEL仓库

yum install wget
wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
wget http://rpms.remirepo.net/enterprise/remi-release-7.rpm
rpm -Uvh remi-release-7.rpm 
rpm -Uvh epel-release-latest-7.noarch.rpm

yum install yum-utils

启用remi-php73的源，yum update升级会自动升级PHP及扩展

[root@li846-239 ~]# yum-config-manager --enable remi-php73
[root@li846-239 ~]# yum repolist
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * base: mirrors.linode.com
 * epel: kartolo.sby.datautama.net.id
 * extras: mirrors.linode.com
 * remi-php73: mirror.xeonbd.com
 * remi-safe: mirror.xeonbd.com
 * updates: mirrors.linode.com
repo id repo name status
base/7/x86_64 CentOS-7 - Base 10,019
epel/x86_64 Extra Packages for Enterprise Linux 7 - x86_64 13,051
extras/7/x86_64 CentOS-7 - Extras 385
remi-php73 Remi's PHP 7.3 RPM repository for Enterprise Linux 7 - x86_64 305
remi-safe Safe Remi's RPM repository for Enterprise Linux 7 - x86_64 3,188
updates/7/x86_64 CentOS-7 - Updates 1,511
repolist: 28,825


yum update -y

检查PHP版本，重启Apache

[root@li846-239 ~]# php -v
PHP 7.3.4 (cli) (built: Apr 2 2019 13:48:50) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.3.4, Copyright (c) 1998-2018 Zend Technologies
[root@li846-239 ~]# systemctl restart httpd

也可以禁用对应PHP版本的源，选择性升级PHP到对应版本

yum-config-manager --disable remi-php72

顺便升级下php-mcrypt和ZipArchive

yum install php-mcrypt
yum install php-pecl-zip

参考链接：
How To Install Linux, Apache, MySQL, PHP (LAMP) stack On CentOS 7
How to enable EPEL repository?
How to Secure Your Server
Introduction to FirewallD on CentOS
How to Upgrade PHP 5.6 to PHP 7.2 on CentOS VestaCP

PHP MongoDB Replica Set应用

Sat, 23 Sep 2017 16:10:53 +0800

MongoDB是个面向文档管理的NoSQL数据库，能够直接存取JSON数据，支持海量数据。公司内部的一个单点登录系统使用MongoDB来存储用户的session，以便在不同应用，服务器之间共享登录信息，解决了服务器切换用户状态丢失（被登出）的问题。单点登录系统前端采用PHP，与LDAP交互认证用户信息，提供登录界面，API等。MongoDB则采用Replica Set模式以便支持高可用。
在CentOS 6.5上安装MongoDB，首先添加源仓库

$ suod vim /etc/yum.repos.d/mongodb.repo
[mongodb]
name=MongoDB Repository
baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/x86_64/
gpgcheck=0
enabled=0

安装，启动，连接MongoDB

$ sudo yum --enablerepo=mongodb install mongodb-org
$ sudo /sbin/chkconfig --levels 235 mongod on
$ sudo mongod --port 27017 --dbpath /data/db1
$ mongo --port 27017

创建用户SSOReplUser

> use admin 
> db.createUser( { user: "SSOReplUser", pwd: "<password>", roles: [ { role: "root", db: "admin" } ] });

创建集群要用到的key

$ sudo openssl rand -base64 741 > /home/sso/mongodb-keyfile 
$ sudo chmod 600 /home/sso/mongodb-keyfile

编辑MongoDB配置文件

$ sudo vim /etc/mongod.conf
# Replication Options 
# in replicated mongo databases, specify the replica set name here 
replSet=SSOReplSet 
# maximum size in megabytes for replication operation log 
#oplogSize=1024 
# path to a key file storing authentication info for connections # between replica set members keyFile=/home/sso/mongodb-keyfile

重启mongod服务

$ sudo /etc/init.d/mongod stop 
$ sudo /usr/bin/mongod -f /etc/mongod.conf

使用SSOReplUser登录

> use admin 
> db.auth("SSOReplUser", "<password>");

初始化集群

> rs.initiate()
> rs.conf() 
{
 "_id": "SSOReplSet",
 "version": 1,
 "members": [
 {
 "_id": 1,
 "host": "192.168.33.10:27017"
 }
 ]
}

在其他机器上按照上面步骤安装MongoDB，更改配置，复制对应的mongodb-keyfile并启动。
回到192.168.33.10并添加机器

SSOReplSet:PRIMARY> rs.add("192.168.33.11:27017") 
SSOReplSet:PRIMARY> rs.add("192.168.33.12:27017") 
SSOReplSet:PRIMARY> rs.add("192.168.33.13:27017")
#SSOReplSet:PRIMARY> rs.remove("192.168.33.13:27017")

在从机上认证查看

SSOReplSet:SECONDARY> use admin 
SSOReplSet:SECONDARY> db.auth("SSOReplUser", "<password>"); 
SSOReplSet:SECONDARY> rs.status()

MongoDB的Replica set模式最少要求3台机器，以便在PRIMARY机器故障时，能够自我选举出新的PRIMARY,但需要n/2+1的机器投票同意。例如刚才配置了4台机器，那么需要4/2+1=3台机器投票，能够承受一台机器故障。如果是集群有5台机器，则能够承受2台机器故障。因此再配置一台不存储数据的Arbiter机器比较合理。
按照上面的步骤安装，复制mongodb-keyfile文件，但需要更改mongod.conf

$sudo vim /etc/mongod.conf
nojournal=true

然后启动mongod服务并在PRIMARY机器上将这台机器加入机器

SSOReplSet:PRIMARY> use admin 
SSOReplSet:PRIMARY> db.auth("SSOReplUser", "<password>"); 
SSOReplSet:PRIMARY> rs.addArb("<ip of arbiter>");

PHP的mongo扩展安装比较简单，下载对应版本，启用即可。然而在应用过程中发现登录有点慢，启用看PHP mongo扩展profiling功能，查看PHP日志

<?php
\MongoLog::setLevel(\MongoLog::ALL);
\MongoLog::setModule(\MongoLog::ALL);
try{
 echo microtime(true) . PHP_EOL;
 echo "aaa01(primary)" . PHP_EOL;
 $m = new \MongoClient("mongodb://admin:XXXXXXXXX@192.168.33.10:27017/?replicaSet=SSOReplSet ");
 echo microtime(true) . PHP_EOL;
 echo "aaa01(primay), bbb01(secondary),ccc01(secondary),ddd01(secondary)" . PHP_EOL;
 $m = new \MongoClient("mongodb://admin:XXXXXXXXX@192.168.33.10:27017,192.168.33.11:27017,192.168.33.12:27017,192.168.33.13:27017/?replicaSet=SSOReplSet ");
 echo microtime(true) . PHP_EOL;
} catch (\MongoConnectionException $e) {
 var_dump($e);
}

发现PHP连接MongoDB集群是这样子的

即：

1）在连接里面配置了几个MongoDB连接服务器，PHP每个都会创建连接去查询
2）从每台服务器上查询出整个集群的服务器列表，再分别ping和连接这些服务器，如果连接不存在或不匹配则创建，无效的则销毁
3）汇总所有服务器返回集群列表
4）选择离自己最近的服务器并使用该与该服务器的连接

MongoDB 的写操作默认在Primary节点上操作完成即返回成功；读操作默认是也是从Primary上读取，所以需要去查询服务器。由于SSO应用部署在多个数据中心，网络抖动会造成较大影响，跨数据中心的查询并不会很快，如果每次都去连接并查询整个列表是比较耗时。另外如果在php里面配置的是IP而MongoDB Replica Set里面配置的是域名，则连接名会出现不匹配，而创建新的连接并销毁旧连接，也耗时。如果配置的是域名，则需要DNS解析。由于每台PHP服务器均已配置HA检测，最终每个应用只配置了一台服务器，并统一配置MongoDB集群为IP。而连接最快的是在Primary机器上，可以根据本机是否Primary来做HA：

#!/usr/bin/env bash
count=`ps -fe |grep "mongod" | grep -v "grep" | wc -l`
FILE="/home/scripts-bits/master.conf"
SERVER=`hostname`

if [ $count -lt 1 ]; then
 rm -f $FILE
else
 PRIMAY=`/usr/bin/mongo ${SERVER}:27017 --quiet --eval 'printjson(db.isMaster().ismaster);'`
 if [ "$PRIMAY" == "true" ]; then
 	if [ ! -f "$FILE" ]; then
 		touch "$FILE"
 	fi
 	REMOVE=`/usr/bin/mongo ${SERVER}:27017/admin --quiet /home/scripts-bits/mongo_status.js`
 fi
fi

删除故障节点(not reachable/healthy)的脚本mongo_status.js:

db.auth('admin','<password>');
conf=rs.status();
members=conf["members"];
for(i in members){
	if(members[i]["state"] == 8){
		rs.remove(members[i]["name"]);
	}
}

这中间也出现过因为网络/机器故障，导致PHP等待连接超时的情况的，将该机器从集群中移除即可。然而当服务器是启动的（可以到达）情况下，MongoDB故障，则不会超时。可以更改connectTimeoutMS，以便减少等待。
MongoDB的日志默认都是记录在/var/log/mongodb/下面并且会越来越大。创建Python脚本来定时清除它：

#!/bin/env python
import commands
import datetime,time

def rotate_log(path, expire = 30):
 str_now = time.strftime("%Y-%m-%d")
 dat_now = time.strptime(str_now, "%Y-%m-%d")
 array_dat_now = datetime.datetime(dat_now[0], dat_now[1], dat_now[2])
 lns = commands.getoutput("/bin/ls --full-time %s|awk '{print $6, $9}'" % path)
 for ln in lns.split('\n'):
 ws = ln.split()
 if len(ws) != 2:
 continue
 ws1 = time.strptime(ws[0], "%Y-%m-%d")
 ws2 = datetime.datetime(ws1[0], ws1[1], ws1[2])
 if (array_dat_now - ws2).days > expire:
 v_del = commands.getoutput("/bin/rm -rf %s/%s" % (path, ws[1]))


def rotate_mongo():
 # get mongo pid
 mongo_pid = commands.getoutput("/sbin/pidof mongod")
 #print mongo_pid
 # send Sig to mongo
 if mongo_pid != '':
 cmd = "/bin/kill -USR1 %s" % (mongo_pid)
 # print cmd
 mongo_rotate = commands.getoutput(cmd)
 else:
 print "mongod is not running..."

if __name__ == "__main__":
 log_path = "/var/log/mongodb/"
 expire = 30
 rotate_mongo()
 rotate_log(log_path, expire)

加入到crontab里面去执行

10 1 * * * /usr/bin/python /home/sso/mongo_rotate.py > /dev/null 2>&1

参考连接
mongodb与mysql相比的优缺点
 PHP MongoDB 复制集合
 MongoDB Replication
MongoDB Enable Auth
MongoDB Rotate Log Files
Blocking connect() leads to cumulative timeouts for multiple inaccessible servers
How Raft consensus algorithm will make replication even better in MongoDB 3.2
Write Concern for Replica Sets
MongoDB Read Preference

日志系统设计

Mon, 03 Oct 2016 22:35:33 +0800

日志系统是项目开发/运维当中非常重要的一部分，提供产品使用情况，跟踪调试信息等。以前都是各个项目各自实现日志记录，比如PHP、JAVA各自实现一套，如果要跨项目/服务器进行查询/跟踪/统计，则比较麻烦，比如Web后台–>业务模块–>基础组件，客户端–>公共接口–>业务模块等等。
目前的项目都是将日志写入本地，首先需要定义统一的规范：

格式
DateTime | ServerIP | ClientIP | PID | RequestID| Type | Level | Message| Code

解释
DateTime：记录日志的当前时间戳
ServerIP：当前服务器IP
ClientIP:客户端IP
PID：进程ID
RequestID：交易号，即请求的唯一标识，使用uniqid(+UserCode)或UUID或，一次请求会有多条日志，，用于关联本次请求内的相关日志
Type：日志类型，比如统计，操作（审计），业务等
Level：日志等级
Message：日志内容，当为值为数组或者对象时转为JSON
Type为RUNTIME时，表示运行日志，属性：自定义
Type为HTTP时，表示来源请求，属性：Url，Method（Get/Post），Params，RemoteIP，UserAgent，ReferUrl[，Action，Method]
Type为REST时，表示外部调用，属性：Type（Http/Https），Url,Port，RequestParams，Response，RunTime；
Type为SQL时，表示SQL执行，属性：Sql，RunTime
Code：标识码，记录错误码、响应码、统计码、版本、自定义信息，方便统计

这里的RequestID由入口处自动产生，用于标识一次请求，关联所产生的所有日志，需要在各个项目之间传递。为了减少日志，Level通常为Info级别，避免产生过多日志。为了方便调试追踪，RequestID和Level也可以在其他参数中指明，比如HTTP头里面附加。
然后是日志收集：客户端收走日志系统，发送给日志系统服务端。
然后分析处理呈现：服务端将接收到的日志，发给处理其他组件分析处理，提供Web界面的查询系统。研发人员，可以错误信息，定位问题；获悉程序运行情况进行调优；大数据分析日志，得出产品使用情况；运维平台则可以进行业务报警。

日志产生由个语言依照规范自行实现，收集、保持则由Flume和Kafka实现。Flume是一个分布式的日志收集、合并、移动系统，能够监控文件变化，将变化部分传输出去。Kafka是一个分布式的发布/订阅的消息流平台，包括Broker，Consumer，Producer都支持分布式，依赖Zookeeper实现。

在PHP上面的实现，一开始使用log4php，看起来很美好，但是性能很差，对业务影响较大。决定再次简化，砍掉不必要的东西（Socket，邮件等等），在C语言开发的PHP日志扩展SeasLog基础上在做开发，将日志文件保存在本地。为了减少日志所占用内存，每超过一定的大小的日志即进行保存，否则在最后进行保存，利用了Nginx的fastcgi_finish_request特性。生产上发现，每天产生的文件日志太大了，需要控制日志信息大小、等级，并及时清理。
对于Web后台，还结合FirePHP，将日志直接输出到浏览器，方便边运行变调试。

参考链接：
最佳日志实践
 Optimal Logging
Flume+Kafka收集Docker容器内分布式日志应用实践
 基于Flume的美团日志收集系统(一)架构和设计
 Twitter是如何构建高性能分布式日志的
 开源日志系统比较
 Kafka剖析（一）：Kafka背景及架构介绍
 基于Flume的野狗实时日志系统的演进和优化
 EVODelavega/phpkafka
有赞统一日志平台初探
 RabbitMQ和kafka从几个角度简单的对比
 Flume-ng的原理和使用
 利用flume+kafka+storm+mysql构建大数据实时系统

使用Docker Compose管理Docker容器

Fri, 30 Sep 2016 00:10:36 +0800

上一篇创建了一个PHP的运行环境，现在需要一个MySQL服务，直接运行：

root@thinkpad:~# docker run --name rocket-mysql -v /home/rocketfish/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7

就自动下载并得到一个mysql版本为5.7的服务镜像。
这时候，要运行一个Web服务我们需要运行两次的docker run才可以，如果还有更多的Web容器或其他的服务容器呢？
Docker官方提倡一个容器仅提供一个服务，多个服务/容器可以使用docker-compose来管理。
docker-compose本身是一个Python写的工具，可以直接通过pip安装：

root@thinkpad:~# sudo pip install --upgrade pip

如果你本地并没有Python环境，也可以采用docker-compose的docker镜像来运行：

root@thinkpad:/home/compose-web# curl -L https://github.com/docker/compose/releases/download/1.8.0/run.sh > /usr/local/bin/docker-compose
root@thinkpad:/home/compose-web# docker-compose --version
#开始下载镜像，建议用第一种

查看帮助

root@thinkpad:~# docker-compose -h
Define and run multi-container applications with Docker.

Usage:
 docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
 docker-compose -h|--help

Options:
 -f, --file FILE Specify an alternate compose file (default: docker-compose.yml)
 -p, --project-name NAME Specify an alternate project name (default: directory name)
 --verbose Show more output
 -v, --version Print version and exit
 -H, --host HOST Daemon socket to connect to

 --tls Use TLS; implied by --tlsverify
 --tlscacert CA_PATH Trust certs signed only by this CA
 --tlscert CLIENT_CERT_PATH Path to TLS certificate file
 --tlskey TLS_KEY_PATH Path to TLS key file
 --tlsverify Use TLS and verify the remote
 --skip-hostname-check Don't check the daemon's hostname against the name specified
 in the client certificate (for example if your docker host
 is an IP address)

Commands:
 build Build or rebuild services
 bundle Generate a Docker bundle from the Compose file
 config Validate and view the compose file
 create Create services
 down Stop and remove containers, networks, images, and volumes
 events Receive real time events from containers
 exec Execute a command in a running container
 help Get help on a command
 kill Kill containers
 logs View output from containers
 pause Pause services
 port Print the public port for a port binding
 ps List containers
 pull Pulls service images
 push Push service images
 restart Restart services
 rm Remove stopped containers
 run Run a one-off command
 scale Set number of containers for a service
 start Start services
 stop Stop services
 unpause Unpause services
 up Create and start containers
 version Show the Docker-Compose version information

这些命令包括了创建/启动/停止/暂停/继续运行容器。
首先要创建docker-compose.yml，这是一个YAML格式的文档

mkdir docker
cd docker
mkdir web
mkdir db
vim docker-compose.yml

内容如下：

version: '2'
services:
 db:
 image: mysql:5.7
 ports:
 - "3306:3306"
 restart: always
 environment:
 MYSQL_ROOT_PASSWORD: root
 MYSQL_DATABASE: web
 MYSQL_USER: root
 MYSQL_PASSWORD: rootweb
 volumes:
 - ./db/data:/var/lib/mysql
 web:
 depends_on:
 - db
 image: nginx-php-fpm:phalcon
 ports:
 - "80:80"
 restart: always
 environment:
 WEB_DB_HOST: db:3306
 WEB_DB_PASSWORD: root
 volumes:
 - ./web/html:/var/www/html/
 links:
 - db

这里的environment定义了环境变量，比如host的MAC，就可以在docker容器的系统变量里面得到，各个编程语言都有获取系统环境变量的方法。这些变量也可以组织起来放在文件里面加载进去，参考这里。
这里的volumes定义了要映射进容器的文件或文件夹或者数据容器，可以参考这里。注意，多个容器共享同一个目录，会出现写冲突，比如MySQL，多个实例，数据目录需要分开。所以设计好你的程序，哪一部分是需要只读的（可以共享)，哪一部分是需要写的；写的部分是否可以放到各自临时目录，或者其他公共服务里面。
运行并查看

root@thinkpad:/home/compose-web# docker-compose up -d
Creating network "composeweb_default" with the default driver
Creating composeweb_db_1
Creating composeweb_web_1
root@thinkpad:/home/compose-web# docker-compose ps
 Name Command State Ports 
------------------------------------------------------------------------------------
composeweb_db_1 docker-entrypoint.sh mysqld Up 0.0.0.0:3306->3306/tcp 
composeweb_web_1 /start.sh Up 443/tcp, 0.0.0.0:80->80/tcp 
#也可以使用原来的命令
root@thinkpad:/home/compose-web# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
efbdaf257748 nginx-php-fpm:phalcon "/start.sh" 13 seconds ago Up 11 seconds 0.0.0.0:80->80/tcp, 443/tcp composeweb_web_1
a6935d20911e mysql:5.7 "docker-entrypoint.sh" 14 seconds ago Up 13 seconds 0.0.0.0:3306->3306/tcp composeweb_db_1

docker-compose up -d ，将会在后台启动并运行所有的容器。
docker-compose仅仅提供了对多个docker服务的管理，仍然可以在这些容器上运行原来的docker命令。检查下web容器的IP：

root@thinkpad:/home/compose-web# docker inspect composeweb_web_1 | grep IPAddress
 "SecondaryIPAddresses": null,
 "IPAddress": "",
 "IPAddress": "172.18.0.3",

然后访问：http://172.18.0.3/ 就可以看到web页面了。
如果想要停止服务，可以用docker-compose stop：

root@thinkpad:/home/compose-web# docker-compose stop db
Stopping composeweb_db_1 ... done
root@thinkpad:/home/compose-web# docker-compose stop web
Stopping composeweb_web_1 ... done

再次启动，得到相同名称的服务:

root@thinkpad:/home/compose-web# docker-compose up -d
Starting composeweb_db_1
Starting composeweb_web_1

各个容器的名称也可以在配置文件里面通过参数container_name来指定。
docker-compose的配置还有很多其他的参数，可以参考这里。比如刚才我们通过docker inspect来查找容器IP，也可以配置成静态IP：

version: '2'

services:
 app:
 image: nginx-php-fpm:phalcon
 networks:
 app_net:
 ipv4_address: 172.18.0.10
 ipv6_address: 2001:3984:3989::10

networks:
 app_net:
 driver: bridge
 driver_opts:
 com.docker.network.enable_ipv6: "true"
 ipam:
 driver: default
 config:
 - subnet: 172.18.0.0/24
 gateway: 172.18.0.1
 - subnet: 2001:3984:3989::/64
 gateway: 2001:3984:3989::1

也可以自定义网络。
刚才我们的配置文件里面直接指定了镜像，也可以指定Dockerfile镜像构建，假如Dockerfile在web目录下面:

build:
 context: ./web

或者直接指明Dockerfile：

build:
 context: .
 dockerfile: Dockerfile-alternate

实际上，docker-compose的配置已经覆盖了Dockerfile的配置项，也可以直接用于构建多个docker服务，比如指定运行的命令

command: [/bin/bash]

这里的入口程序，如果不能持续运行的话，运行完成后，docker就会退出。所以如果你需要可以后台运行的docker容器，那么入口程序，就必须保持一个程序在前台运行，不退出，比如运行crontab的镜像，入口程序可以是：

cron && bash

cron这个程序是在后台运行的，如果不配合前台程序bash，容器执行玩cron就会退出了。其他运行crontab的容器，大都是强制一个程序在前台不退出，比如这个：

cron && tail -f /var/log/cron.log

这里需要注意一下，通过docker设置的environment values在容器内的cli下面执行时取不到的，比如printenv，使用cron后台运行时取不到外部设置的变量，但是手动执行时又可以。这些外部环境变量只能在ENTRYPOINT或者CMD所执行的shell里面去设置，比如在CMD执行start.sh:

printenv | grep -E "^HOST" > /root/env.conf && cron && bash

Docker compose还可以跟Docker Swarm结合。

参考链接：
Install Docker Compose
Quickstart: Docker Compose and WordPress
YAML 模板文件
 Introduction to Docker Compose Tool for Multi-Container Applications
Dockerfile基本结构
 How to Get Environment Variables Passed Through docker-compose to the Containers
Access environment variables from crontab into a docker container
How can I access Docker set Environment Variables From a Cron Job
Dockerfile里指定执行命令用ENTRYPOING和用CMD有何不同？
What is the difference between CMD and ENTRYPOINT in a Dockerfile?
Docker difference between run, cmd, entrypoint commands

基于Docker的Nginx + PHP-FPM + Phalcon镜像

Wed, 28 Sep 2016 23:34:40 +0800

上一篇简单介绍了Docker的安装，运行，这一篇来构建一个基于Nginx和PHP-FPM的Phalcon镜像。在官方找了以下，单独的Nginx和PHP镜像更加流行，混合的反倒不是很受欢迎。其实官方并不提倡在一个容器里面运行多个服务，最好是一个容器只对外提供一个服务：一个容器启动时仅仅运行一个命令（其实里面可以包含多个），也方便部署扩展升级。多个服务之间可以使用Docker Compose来管理。但是Docker并不阻止创建包含多个服务器的镜像，为了方便，所以我们仍然可以自己构建。
构建镜像可以有好几种方式，比如基于Alpine Linux或phusion/baseimage-docker构建，或者基于Ubuntu，CentOS等构建，又或者在PHP，Nginx的基础镜像上构建。注意：如果要采用Ubuntu或者CentOS构建，可能需要一些额外的工作，以便保持镜像轻量稳定运行。
这里采用已有的richarvey/nginx-php-fpm来构建，它是一个基于Nginx官方镜像来构建的。
从Github上拉取相关文件从Dockerfile构建：

$ sudo git clone https://github.com/ngineered/nginx-php-fpm
$ sudo docker build -t nginx-php-fpm:latest .

关于Dockerfile的相关解释，可以参考这里。当然也可以直接拉取镜像使用

$ sudo docker pull richarvey/nginx-php-fpm
# 也可以直接运行，会自动拉取
#$ sudo docker run -d richarvey/nginx-php-fpm

查看本地的镜像，连单独的nginx也来了：

root@thinkpad:~# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx-php-fpm latest 4fc9ac9f2945 7 hours ago 228.5 MB
nginx mainline-alpine 00bc1e841a8f 5 days ago 54.21 MB

这里的mainline-alpine是指基于Alpine Linux构建的。Alpine Linux是一个仅有5M大小的linux系统，采用apk add/search来安装/查找相应软件，有许多镜像都是基于它构建的，官方PHP镜像也有基于它构建的Docker镜像。
然后运行nginx-php-fpm：

root@thinkpad:~# docker run --name web -d richarvey/nginx-php-fpm

docker inspect命令用来查看容器的相关信息，查看下分配的IP：

root@thinkpad:~# docker inspect web | grep IPAddress
 "SecondaryIPAddresses": null,
 "IPAddress": "172.17.0.2",
 "IPAddress": "172.17.0.2",

然后在浏览器里面访问：http://172.17.0.2/就可以看到phpinfo的页面。到这里，Nginx + PHP的web容器就已经运行起来了，对应的Nginx和PHP进程可以在宿主机器上直接查看：

root@thinkpad:~# ps aux | grep nginx
root 18167 0.0 0.0 13696 4300 pts/6 S 01:47 0:00 nginx: master process /usr/sbin/nginx
systemd+ 18168 0.0 0.0 14144 1868 pts/6 S 01:47 0:00 nginx: worker process
systemd+ 18169 0.0 0.0 14144 1868 pts/6 S 01:47 0:00 nginx: worker process
systemd+ 18170 0.0 0.0 14144 1868 pts/6 S 01:47 0:00 nginx: worker process
systemd+ 18171 0.0 0.0 14144 1868 pts/6 S 01:47 0:00 nginx: worker process
systemd+ 18172 0.0 0.0 14144 1868 pts/6 S 01:47 0:00 nginx: worker process
root 18190 0.0 0.0 21292 1012 pts/18 S+ 01:47 0:00 grep --color=auto nginx
root@thinkpad:~# ps aux | grep php-fpm
root 18166 0.0 0.2 167880 23364 pts/6 S 01:47 0:00 php-fpm: master process (/etc/php5/php-fpm.conf)
systemd+ 18173 0.0 0.1 167880 8620 pts/6 S 01:47 0:00 php-fpm: pool www
systemd+ 18174 0.0 0.1 167880 8620 pts/6 S 01:47 0:00 php-fpm: pool www
systemd+ 18175 0.0 0.1 167880 8620 pts/6 S 01:47 0:00 php-fpm: pool www
root 18192 0.0 0.0 21292 1032 pts/18 S+ 01:47 0:00 grep --color=auto php-fpm

接下来要为这个容器添加Phalcon扩展。首先要进入容器里面，使用docker attach命令进入：

root@thinkpad:~# docker attach web

结果在这里等了半天进不去。。。。查看下当前镜像入口程序：

root@thinkpad:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
94176348a939 nginx-php-fpm "/start.sh" 6 seconds ago Up 5 seconds 80/tcp, 443/tcp web

这个容器启动的时候运行的是start.sh这个脚本，这个脚本运行了Supervisor工具。于是重新启动容器，运行/bin/bash

#终止容器运行
root@thinkpad:~# docker stop web
web
#删除容器
root@thinkpad:~# docker rm web
web
#重新运行
root@thinkpad:~# docker run --name web -d -t -i nginx-php-fpm /bin/bash
ea21e10df702644a83ed75930b30c7764a786c4feabdf17cd868f86640137c47
root@thinkpad:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ea21e10df702 nginx-php-fpm "/bin/bash" 6 seconds ago Up 5 seconds 80/tcp, 443/tcp web
root@thinkpad:~# docker attach web
#进来了
bash-4.3# ls
bin etc lib media proc run srv sys usr
dev home linuxrc mnt root sbin start.sh tmp var

就可以进去了。
先安装编译相关工具包：

bash-4.3# apk --no-cache add php5-dev
bash-4.3# apk --no-cache add gcc
bash-4.3# apk --no-cache add make
bash-4.3# apk --no-cache add autoconf
bash-4.3# apk --no-cache add libc-dev
fetch http://dl-cdn.alpinelinux.org/alpine/v3.4/main/x86_64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.4/community/x86_64/APKINDEX.tar.gz
(1/2) Installing musl-dev (1.1.14-r12)
(2/2) Installing libc-dev (0.7-r0)
OK: 334 MiB in 106 packages

编译安装Phalcon：

bash-4.3# cd /home
bash-4.3# git clone --depth=1 git://github.com/phalcon/cphalcon.git
bash-4.3# cd cphalcon/build
bash-4.3# ./install
bash-4.3# ls -la /usr/lib/php5/modules/ | grep phalcon
-rwxr-xr-x 1 root root 5045264 Sep 28 17:34 phalcon.so

更改PHP扩展的配置：

bash-4.3# cd /etc/php5/conf.d/
bash-4.3# vi phalcon.ini
#添加以下内容
#extension=phalcon.so

#检查扩展是否加载成功
bash-4.3# php -i | grep phalcon
/etc/php5/conf.d/phalcon.ini,
phalcon
phalcon => enabled
phalcon.db.escape_identifiers => On => On
phalcon.db.force_casting => Off => Off
phalcon.orm.cast_on_hydrate => Off => Off
phalcon.orm.column_renaming => On => On
phalcon.orm.enable_implicit_joins => On => On
phalcon.orm.enable_literals => On => On
phalcon.orm.events => On => On
phalcon.orm.exception_on_failed_save => Off => Off
phalcon.orm.ignore_unknown_columns => Off => Off
phalcon.orm.late_state_binding => Off => Off
phalcon.orm.not_null_validations => On => On
phalcon.orm.virtual_foreign_keys => On => On
OLDPWD => /home/cphalcon/build
_SERVER["OLDPWD"] => /home/cphalcon/build
_ENV["OLDPWD"] => /home/cphalcon/build

加载成功了，需要保持本次镜像变更。首先退出容器：

bash-4.3# cd /home
#删除各种不必要的东西，比如gcc
bash-4.3# rm -rf cphalcon/
bash-4.3# exit
exit

然后查看版本并提交变更：

root@thinkpad:~# docker ps -l
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ea21e10df702 nginx-php-fpm "/bin/bash" 31 minutes ago Exited (0) 6 seconds ago web
root@thinkpad:~# docker commit ea2 nginx-php-fpm:phalcon
sha256:bb388df328ecc33fac02dba69759d5c992a145f650a0e5b20ca29a4b122fa933

docker commit命令可以用来提交变更，ea2是container id的前三位，也可以写全；然后跟的是要提交的镜像。这里提交到phalcon这个标签下，以便与原来的区分开。查看所有镜像，发现有两个不同的标签：

root@thinkpad:~# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx-php-fpm phalcon bb388df328ec 11 seconds ago 364.4 MB
nginx-php-fpm latest 4fc9ac9f2945 4 hours ago 228.5 MB

采用新镜像来运行，这里要讲程序运行入口改回/start.sh，以便能正常启动Nginx和PHP-FPM：

root@thinkpad:~# docker rm web
web
root@thinkpad:~# docker run --name web -d -t -i nginx-php-fpm:phalcon /start.sh
deecb19467cda2676b24248e3f55970a2481255c6022a80ffbf5087792ccb559
root@thinkpad:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
deecb19467cd nginx-php-fpm:phalcon "/start.sh" 4 seconds ago Up 3 seconds 80/tcp, 443/tcp web

入口程序改变了，需要再提交一次变更：

root@thinkpad:~# docker stop web
web
root@thinkpad:~# docker ps -l
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c7600e62733d nginx-php-fpm:phalcon "/start.sh" 34 seconds ago Exited (137) 8 seconds ago web
root@thinkpad:~# docker commit c76 nginx-php-fpm:phalcon
sha256:1c97ee169a551dd8441f42b40beafd102c71f3e887e2317dc11ce0ef136ceaf0

运行最终的镜像：

root@thinkpad:~# docker rm web
web
root@thinkpad:~# docker run --name web -d -t -i nginx-php-fpm:phalcon
cb5b0c9e55913a538539e46c53ac7905b21def84a05eb00ef81c4b500853576c
root@thinkpad:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cb5b0c9e5591 nginx-php-fpm:phalcon "/start.sh" 4 seconds ago Up 3 seconds 80/tcp, 443/tcp web

访问http://172.17.0.2/，便可以在页面找到phalcon扩展。
通常我们会将程序和数据分开，挂载外部文件目录到容器里面去：

root@thinkpad:~# docker stop web
web
root@thinkpad:~# docker rm web
web
root@thinkpad:~# docker run --name web -d -t -i -v /home/docker/nginx-php-fpm/src:/var/www/html/ nginx-php-fpm:phalcon
ffd64793fe8e7a2a95b68f514e221b7ec3b6cadfe668c016f55a7bb6d48bc702

-v参数可以用来挂载目录或者文件，可以又多个-v参数。
刚才容器里面做的那些已经添加到Dockerfile里面去，你直接使用它来构建。
至此Nginx + PHP-FPM + Phalcon镜像构建完成，介绍绍了如何进入容器，提交变更，网络访问和文件挂载。

参考链接：
A minimal Ubuntu base image modified for Docker-friendliness
eboraas/phalcon
基于Docker的PHP开发环境
 Docker for PHP Developers
Docker在PHP项目开发环境中的应用
 使用 Supervisor 来管理进程
 PHP C扩展框架Phalcon
Alpine Linux，一个只有5M的Docker镜像

PagerDuty Integration Development

Wed, 18 May 2016 22:35:05 +0800

Download

参考链接：
PagerDuty
PHP测试框架初探：PHPUnit

PHP 处理行结束符

Mon, 31 Aug 2015 13:02:11 +0800

我们平台有个功能支持导入一行一个编号的文本，进行批量处理，类似CSV文件，代码是这样的：

$arrLine = file($strFilePath);
foreach($arrLine as $k => $v){
}

一直用都用的好好的，今天有同事导入却不正常了。用记事本打开要导入的文件来看，发现文件里面的内容都是只有一行；用EditPlus打开来看却又是正常的，不过显示是Mac平台的文件，猜测应该是换行符不一样导致的。Google了一下，发现果然如此，不同操作系统的行结束符是不一样的：

Windows\DOS：\r\n <\li>
Unix\Linux：\n <\li>
Macintosh：\r <\li>

另外，TCP/IP协议传输文本结束符也是\r\n。PHP的文件系统函数file和fgets默认不检测行结束符，所以不能正确处理。可以将这些换行符处理成其他的，再来断行

$strFileContent = str_replace(array("/r/n", "/r", "/n"), ",", $strFileContent); 
$arrLine = explode(',' , $strFileContent);

PHP官网也提供了相应的解决方法，更改php.ini配置，或者ini_set(‘auto_detect_line_endings’, ‘On’)即可。

Note: 在读取在 Macintosh 电脑中或由其创建的文件时，如果 PHP 不能正确的识别行结束符，启用运行时配置可选项 auto_detect_line_endings 也许可以解决此问题。

auto_detect_line_endings boolean
当设为 On 时，PHP 将检查通过 fgets() 和 file() 取得的数据中的行结束符号是符合 Unix，MS-DOS，还是 Macintosh 的习惯。

这使得 PHP 可以和 Macintosh 系统交互操作，但是默认值是 Off，因为在检测第一行的 EOL 习惯时会有很小的性能损失，而且在 Unix 系统下使用回车符号作为项目分隔符的人们会遭遇向下不兼容的行为。

PHP从4.3开始使用常量PHP_EOL来代替不同平台的换行符，在代码中也应该使用PHP_EOL而不是写\r\n，否则会造成不必要的平台环境问题。

参考链接：
Difference between \n and \r?
what is the difference between windows csv and mac csv?
PHP Fucntion file
PHP auto-detect-line-endings
When do I use the PHP constant “PHP_EOL”?

PHP C扩展框架Phalcon

Thu, 30 Jul 2015 13:33:59 +0800

Phalcon是一个C语言写的高性能PHP框架，相比PHP写的框架，它作为PHP的扩展在进程开启时便加载了，节省了每一次请求时的类库加载、MVC框架分派的开销。前面提到的使用Zephir来开发PHP扩展也是这个项目贡献的。
在CentOS 上安装Phalcon，因为之前安装过zephire了，所以直接下载cphalcon来编译安装就可以了，可以参照这里安装所需其他lib

git clone --depth=1 git://github.com/phalcon/cphalcon.git
cd cphalcon/build/
sudo ./install

sudo vim /etc/php.d/phalcon.ini

创建phalcon.ini增加以下内容

[phalcon]
extension=phalcon.so

这里单独把phalcon.ini单独配置，是因为Phalcon扩展加载要在PDO扩展之后，而我的PDO也是单独配置的。如果不是的话会提示这个错误：

$ php -m | grep phalcon
PHP Warning: PHP Startup: Unable to load dynamic library '/usr/lib64/php/modules/phalcon.so' - /usr/lib64/php/modules/phalcon.so: undefined symbol: php_pdo_get_dbh_ce in Unknown on line 0

与Zend Framwork类似，Phalcon也提供开发工具用于快速生成项目骨架

git clone https://github.com/phalcon/phalcon-devtools.git
cd phalcon-devtools
./phalcon.sh
sudo ln -s ~/phalcon-devtools/phalcon.php /usr/bin/phalcon
sudo chmod ugo+x /usr/bin/phalcon

phalcon commands

注意，这个开发工具也是需要依赖Phalcon扩展的，否则会提示

$ phalcon command
PHP Fatal error: Class 'Phalcon\Script' not found in /home/vagrant/phalcon-devtools/phalcon.php on line 40
PHP Stack trace:
PHP 1. {main}() /home/vagrant/phalcon-devtools/phalcon.php:0

生成一个测试项目store

phalcon scaffold store

按照官方的Nginx说明配置

server {

 listen 8005;
 server_name store.localhost;

 index index.php index.html index.htm;
 set $root_path '/usr/share/nginx/html/tutorial/store/public';
 root $root_path;

 try_files $uri $uri/ @rewrite;

 location @rewrite {
 rewrite ^/(.*)$ /index.php?_url=https://courages.us/$1;
 }

 location ~ \.php {
 fastcgi_pass unix:/tmp/php5-fpm.sock;
 fastcgi_index /index.php;

 include fastcgi.conf;

 fastcgi_split_path_info ^(.+\.php)(/.+)$;
 fastcgi_param PATH_INFO $fastcgi_path_info;
 fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }

 location ~* ^/(css|img|js|flv|swf|download)/(.+)$ {
 root $root_path;
 }

 location ~ /\.ht {
 deny all;
 }
}

访问一下192.168.33.14:8005，提示：Access denied。。。查看Nginx错误日志

[root@vagrant nginx]# tail -n 20 error.log
2015/07/28 03:41:42 [error] 7343#0: *1 FastCGI sent in stderr: "Access to the script '/usr/share/nginx/html/tutorial/store/public' has been denied (see security.limit_extensions)" while reading response header from upstream, client: 192.168.33.1, server: store.localhost, request: "GET / HTTP/1.1", upstream: "fastcgi://unix:/tmp/php5-fpm.sock:", host: "192.168.33.14:8005"

一开始还以为是PHP-FPM配置security.limit_extensions引起的，后来发现这个这个参数默认就是注释掉的，没限制。最后在这里找到答案：原来是之前安装Nginx时配置了：cgi.fix_pathinfo=0，将它改回1（默认值）就可以了。当这个参数为1时，会把 PATH_TRANSLATED 转换为 SCRIPT_FILENAME。当然把这个参数去掉也是可以的

 ;fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

重启Nginx

sudo service nginx restart

与其他PHP框架一样，Phalcon 支持MVC应用开发，提供了诸多组件如，数据库，缓存，队列等。
Phalcon\DI 作为全局的服务管理，用于服务注册，比如数据库，缓存，文件等。将这些资源统一起来管理，以便其他地方可以调用，各个需要的地方不再需要是new 一个对象，解除耦合关系。
Phalcon\Events\Manager作为全局的事件管理，用于事件注册，触发，以便自定义消息通知，如数据库查询事件，初始化事件。
Phalcon还有一个比较有特色的地方支持注释解析: Phalcon\Annotations 。官方教程举例如何使用注释做输出缓存。首先在Dispatcher服务中注册一个监听dispactch事件的缓存插件

<?php

$di['dispatcher'] = function () {

 $eventsManager = new \Phalcon\Events\Manager();

 // 添加插件到dispatch事件中
 $eventsManager->attach('dispatch', new CacheEnablerPlugin());

 $dispatcher = new \Phalcon\Mvc\Dispatcher();
 $dispatcher->setEventsManager($eventsManager);
 return $dispatcher;
};

然后实现监听的缓存插件

<?php

/**
 * 为视图启动缓存，如果被执行的action带有@Cache 注释单元。
 *
 */
class CacheEnablerPlugin extends \Phalcon\Mvc\User\Plugin
{

 /**
 * 这个事件在dispatcher中的每个路由被执行前执行
 *
 */
 public function beforeExecuteRoute($event, $dispatcher)
 {

 // 解析目前访问的控制的方法的注释
 $annotations = $this->annotations->getMethod(
 $dispatcher->getActiveController(),
 $dispatcher->getActiveMethod()
 );

 // 检查是否方法中带有注释名称‘Cache’的注释单元
 if ($annotations->has('Cache')) {

 // 这个方法带有‘Cache’注释单元
 $annotation = $annotations->get('Cache');

 // 获取注释单元的‘lifetime’参数
 $lifetime = $annotation->getNamedParameter('lifetime');

 $options = array('lifetime' => $lifetime);

 // 检查注释单元中是否有用户定义的‘key’参数
 if ($annotation->hasNamedParameter('key')) {
 $options['key'] = $annotation->getNamedParameter('key');
 }

 // 为当前dispatcher访问的方法开启cache
 $this->view->cache($options);
 }

 }

}

现在就可以使用注释来进行缓存了

<?php

class NewsController extends \Phalcon\Mvc\Controller
{

 public function indexAction()
 {

 }

 /**
 * This is a comment
 *
 * @Cache(lifetime=86400)
 */
 public function showAllAction()
 {
 $this->view->article = Articles::find();
 }

 /**
 * This is a comment
 *
 * @Cache(key="my-key", lifetime=86400)
 */
 public function showAction($slug)
 {
 $this->view->article = Articles::findFirstByTitle($slug);
 }

}

为Action增加了缓存，但对Action的代码改动为0（无侵入）并且非常简洁。数据模型里面也可以使用注释来对字段进行处理

<?php

use Phalcon\Mvc\Model;

class Robots extends Model
{
 /**
 * @Primary
 * @Identity
 * @Column(type="integer", nullable=false)
 */
 public $id;

 /**
 * @Column(type="string", length=70, nullable=false)
 */
 public $name;

 /**
 * @Column(type="string", length=32, nullable=false)
 */
 public $type;

 /**
 * @Column(type="integer", nullable=false)
 */
 public $year;
}

路由解析也可以使用RouterAnnotations反射来实现

?php

/**
 * @RoutePrefix("/api/products")
 */
class ProductsController
{

 /**
 * @Get("/")
 */
 public function indexAction()
 {

 }

 /**
 * @Get("/edit/{id:[0-9]+}", name="edit-robot")
 */
 public function editAction($id)
 {

 }

 /**
 * @Route("/save", methods={"POST", "PUT"}, name="save-robot")
 */
 public function saveAction()
 {

 }

 /**
 * @Route("/delete/{id:[0-9]+}", methods="DELETE",
 * conversors={id="MyConversors::checkId"})
 */
 public function deleteAction($id)
 {

 }

 public function infoAction($id)
 {

 }

}

是不是跟Java annotation有点像？之前介绍的PHPUnit，Zend Framework，还有Symfony 2 和 Doctrine 2已经在PHP层面上支持，使用ReflectionClass便可实现。
Phalcon也支持创建命令行应用，可以将PHP应用打包成Phar，直接运行，也可以结合命令行颜色进行输出。

参考链接：
Nginx 安装说明（Nginx Installation Notes）
Can’t upgrade to Phalcon 1.3.0
Nginx/PHP-FPM “Access denied.” error
Access denied (403) for PHP files with Nginx + PHP-FPM
Phalcon 开发工具（Phalcon Developer Tools）
IDE autocomplete for PhalconPHP
Annotations in PHP: They Exist
PHP Annotations Are a Horrible Idea
PHP CLI Colors – PHP Class Command Line Colors (bash)

使用Phar打包发布PHP程序

Tue, 21 Jul 2015 11:12:52 +0800

上一遍介绍PHPUnit时，下载的PHPUnit是个Phar格式的文件并且可以独立运行。Phar归档是PHP 5.3增加的新特性，借鉴了JAVA中的JAR归档，可以将整个目录下的文件打包成单个可执行文件。虽然单个PHP文件也是可执行（Composer的install就是单个PHP文件执行创建对应的Phar），但是显得不方便。
Phar的创建、引用、解压、转换均可以在PHP中完成。要创建Phar需要更改php.ini如下

;phar.readonly = On
phar.readonly = Off

首先在swoole\server目录下创建一个需要打包的文件swoole.php

<?php
$serv = new swoole_server("127.0.0.1", 9002);
$serv->set(array(
 'worker_num' => 8, //工作进程数量
 'daemonize' => true, //是否作为守护进程
));
$serv->on('connect', function ($serv, $fd){
 echo "Client:Connect.\n";
});
$serv->on('receive', function ($serv, $fd, $from_id, $data) {
 $serv->send($fd, 'Swoole: '.$data);
 $serv->close($fd);
});
$serv->on('close', function ($serv, $fd) {
 echo "Client: Close.\n";
});
$serv->start();

在swoole目录下面创建index.php

<?php
require 'server/swoole.php';

测试一下是否能正常运行

[root@vagrant-centos64 swoole]php index.php
[root@vagrant-centos64 swoole]# netstat -apn | grep 9002
tcp 0 0 127.0.0.1:9002 0.0.0.0:* LISTEN 8436/php

在swoole目录下创建执行打包操作的文件build.php

<?php
$dir = __DIR__; // 需要打包的目录
$file = 'swoole.phar'; // 包的名称, 注意它不仅仅是一个文件名, 在stub中也会作为入口前缀
$phar = new Phar(__DIR__ . '/' . $file, FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::KEY_AS_FILENAME, $file);
// 开始打包
$phar->startBuffering();
$phar->buildFromDirectory($dir);
$phar->delete('build.php');
// 设置入口
$phar->setStub("<?php
Phar::mapPhar('{$file}');
require 'phar://{$file}/index.php';
__HALT_COMPILER();
?>");
$phar->stopBuffering();
// 打包完成
echo "Finished {$file}\n";

进行打包

[root@vagrant-centos64 swoole]$ php build.php
Finished swoole.phar

测试执行一下

[root@vagrant-centos64 swoole]$ php swoole.phar
[root@vagrant-centos64 swoole]# netstat -apn | grep 9002
tcp 0 0 127.0.0.1:9002 0.0.0.0:* LISTEN 8635/php

到这里swoole.phar可以单独发布执行力。也可以在其他项目（比如WEB）里面引用，例如

<?php
include 'swoole.phar';
//引用里面的文件
//include 'phar://swoole.phar/server/swoole.php';

SegmentFault便是将PHP打包成Phar进行发布的。
打包完成后，也可以将Phar转成Zip格式或解压出来，比如解压PHPUnit

<?php
$phar = new Phar('phpunit.phar');
$phar->convertToExecutable(Phar::ZIP);
//$phar->extractTo('phpunit');

刚才我们这样运行的：php swoole.phar，就是还需要在PharP包前面还要加一个php。如果想做成直接可运行的Phar包，可以像单个PHP可执行文件那样在文件开头加上：#!/usr/bin/env php

$phar->setStub("#!/usr/bin/env php
<?php
Phar::mapPhar('{$file}');
require 'phar://{$file}/index.php';
__HALT_COMPILER();
?>");

运行一下

./swoole.phar

注意如果你在window下面编辑刚才段代码的话，可能会报错：-bash: ./swoole.phar: /usr/bin/env: bad interpreter: No such file or directory。解决办法便是更改换行符为Unix格式，参见这里。

GitHub上有个项目：phar-composer可以利用Composer来打包相应的项目为单个可执行文件。

参考链接：
使用phar上线你的代码包
 PHP的Phar简介
 使用Phar来打包发布PHP程序
 Packaging Your Apps with Phar
PHP V5.3 中的新特性，第 4 部分: 创建并使用 Phar 归档
 rpm打包利器rpm_create简介

PHP测试框架初探：PHPUnit

Mon, 20 Jul 2015 13:16:03 +0800

最近开始一个新的项目，涉及到了网络通信的客户/端服务端，刚开始都是边写边调试，完成之后觉得有必要留下相关的测试示例，以便日后使用调试。一些PHP项目会把示例写在文件开头的注释里面，但这样又没办法验证是否能正确运行。
workerman是在文件最后留下的运行代码，如RpcClient.php

// ==以下调用示例==
if(PHP_SAPI == 'cli' && isset($argv[0]) && $argv[0] == basename(__FILE__))
{
 //这里是RpcClient的测试用例
}

PHPUnit则是这样的

#!/usr/bin/env php
<?php
if (__FILE__ == realpath($GLOBALS['_SERVER']['SCRIPT_NAME'])) {
 $phar = realpath($GLOBALS['_SERVER']['SCRIPT_NAME']);
 $execute = true;
} else {
 $files = get_included_files();
 $phar = $files[0];
 $execute = false;
}

这有点像python

if __name__ == "__main__":
 //这里运行相关调用

这样就可以对单个文件的代码边看边测试，但是这会在相关的代码里面混入不必要的测试用例代码，当有依赖于外部文件又不是很方便，于是便想把这部分测例代码独立出来。
PHPUnit是xUnit测试家族的一员，可以方便对测试代码进行管理，还可以结合其他扩展。依照官网步骤开始：

wget https://phar.phpunit.de/phpunit.phar
chmod +x phpunit.phar
sudo mv phpunit.phar /usr/local/bin/phpunit
phpunit --version
#PHPUnit 4.7.7 by Sebastian Bergmann and contributors.

写一个测试代码（PHPUnit也可以自动生成对应的测试代码）

<?php
namespace Test\Client;
use Client\RPC;
class RPCTest extends \PHPUnit_Framework_TestCase{
	public $pClient = null;
	public $nMatchID = 567;
	public function __construct(){
		parent::__construct();
		
		$arrAddress = array(
				'tcp://127.0.0.1:9001'
		);
		// 配置服务端列表
		RPC::config($arrAddress);
		$this->nMatchID = 567;
		$this->pClient = RPC::instance('\Prize\Service');
	}
	public function testGet(){
		$mxRes = $this->pClient->get($this->nMatchID);
		$this->assertTrue(is_array($mxRes));
		$this->assertGreaterThan(0, count($mxRes));
	}
	public function testSendGet(){
		$this->assertTrue($this->pClient->send_get($this->nMatchID));
	}
	/**
	 * 使用依赖，以便保证在同一个socket链接之内
	 * @depends testSendGet
	 */
	public function testRecvGet(){
		$mxRes = $this->pClient->recv_get($this->nMatchID);
		$this->assertTrue(is_array($mxRes));
		$this->assertGreaterThan(0, count($mxRes));
	}
}

这边的使用了外部类RPC，于是在Bootstrap.php里面定义相关的自动加载规则，以便测试时自动加载

<?php
define('STIE_PATH', getcwd().'/');
define('ROOT_PATH', STIE_PATH);
define('LIB_PATH', ROOT_PATH.'Lib/');
define('TEST_PATH',	ROOT_PATH.'Test/');

spl_autoload_register(function($p_strClassName){
	$arrClassName = explode('\\', trim($p_strClassName, '\\'));
	if(!empty($arrClassName)){
		if($arrClassName[0] == 'Test'){
			$strPath = ROOT_PATH.implode(DIRECTORY_SEPARATOR, $arrClassName).'.php';
		}
		else{
			$strPath = LIB_PATH.implode(DIRECTORY_SEPARATOR, $arrClassName).'.php';
		}
	}
	if(is_file($strPath)){
		include $strPath;
	}
	else{
		throw new Exception("File not find : ".$strPath);
	}
});

现在运行测试代码

phpunit --bootstrap Test/Bootstrap.php Test/

出现了一些警报和错误。其中一个提示找不到PHPUnit_Extensions_Story_TestCase文件：

PHP Warning: include(/usr/share/nginx/html/tutorial/mars/Lib/PHPUnit_Extensions_Story_TestCase.php): failed to open stream: No such file or directory in /usr/share/nginx/html/tutorial/mars/Test/Bootstrap.php on line 20

这文件是一个PHPUnit的基于故事的行为驱动开发（BDD）扩展，于是上网找了下想安装。

PHPUnit现在只支持Composer安装，如果用PEAR安装会提示失败

sudo pear channel-discover pear.phpunit.de
Discovering channel pear.phpunit.de over http:// failed with message: channel-add: Cannot open "http://pear.phpunit.de/channel.xml" (File http://pear.phpunit.de:80/channel.xml not valid (received: HTTP/1.1 410 Gone
))
Trying to discover channel pear.phpunit.de over https:// instead
Discovery of channel "pear.phpunit.de" failed (channel-add: Cannot open "https://pear.phpunit.de/channel.xml" (File https://pear.phpunit.de:443/channel.xml not valid (received: HTTP/1.1 410 Gone
)))

先安装Composer

curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer
composer -V

创建一个composer.json，以便自动下载相关的库

{
 "require-dev": {
 "phpunit/phpunit": "4.7.*",
 "phpunit/phpunit-selenium": ">=1.4",
 "phpunit/dbunit": ">=1.3",
 "phpunit/phpunit-story": "*",
 "phpunit/php-invoker": "*"
 },
 "autoload": {
 "psr-0": {"": "src"}
 },
 "config": {
 "bin-dir": "bin/"
 }
}

运行composer，注意：composer在国内慢的要死，可以参照这里。

composer install --dev

便会在同级目录下面生成一个vendor目录，各自的依赖库都下载在里面，并且生成了autolaod.php，用于加载相关的类库。编辑Bootstarp.php增加一行

include ROOT_PATH."vendor/autoload.php";

再次运行PHPUnit

[vagrant@vagrant-centos64 mars]$ phpunit --bootstrap Test/Bootstrap.php Test/KM/Client/RPCTest
PHPUnit 4.7.7 by Sebastian Bergmann and contributors.

EES

Time: 540 ms, Memory: 14.25Mb

There were 2 errors:

1) Test\KM\Client\RPCTest::testGet
stream_socket_client(): unable to connect to tcp://127.0.0.1:9001 (Connection refused)

/usr/share/nginx/html/tutorial/mars/Lib/Client/Stream.php:19
/usr/share/nginx/html/tutorial/mars/Lib/Client/Stream.php:16
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:174
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:141
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:130
/usr/share/nginx/html/tutorial/mars/Test/Client/RPCTest.php:21
/usr/share/nginx/html/tutorial/mars/Test/Client/RPCTest.php:21

2) Test\KM\Client\RPCTest::testSendGet
stream_socket_client(): unable to connect to tcp://127.0.0.1:9001 (Connection refused)

/usr/share/nginx/html/tutorial/mars/Lib/Client/Stream.php:19
/usr/share/nginx/html/tutorial/mars/Lib/Client/Stream.php:16
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:174
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:141
/usr/share/nginx/html/tutorial/mars/Lib/Client/RPC.php:116
/usr/share/nginx/html/tutorial/mars/Test/Client/RPCTest.php:26
/usr/share/nginx/html/tutorial/mars/Test/Client/RPCTest.php:26

FAILURES!
Tests: 2, Assertions: 0, Errors: 2, Skipped: 1.

这下子没有警报了，只有详细的测试错误报告。刚才的测试代码里面testRecvGet方法依赖于testSendGet，一旦后者失败了，前者便会被跳过。
启动服务端再次运行测试代码

[vagrant@vagrant-centos64 mars]$ phpunit --colors --bootstrap Test/Bootstrap.php Test/
PHPUnit 4.7.7 by Sebastian Bergmann and contributors.

...

Time: 496 ms, Memory: 14.25Mb

OK (3 tests, 5 assertions)

这下子全部测试通过了。

前面运行测试是这样的：phpunit –bootstrap Test/Bootstrap.php Test/。–bootstrap是指在运行测试时首先加载的文件可以在这里面定义一些配置，自动加载规则，最后一个参数Test/是指要测试的目录，也可以指明运行某个测试用例，比如Test/Client/RPCTest，指运行RPCTest这个测试用例。

PHPUnit还有许多其他的命令行参数选项，如果每次这么输入也挺麻烦的，可以做成配置文件，加载运行就好了，比如phpunit.xml.dist

<?xml version="1.0" encoding="UTF-8"?>
<phpunit backupGlobals="false"
 backupStaticAttributes="false"
 colors="true"
 convertErrorsToExceptions="true"
 convertNoticesToExceptions="true"
 convertWarningsToExceptions="true"
 processIsolation="false"
 stopOnFailure="false"
 syntaxCheck="false"
 bootstrap="Test/Bootstrap.php"
>
 <testsuites>
 <testsuite name="Lib Test Suite">
 <directory>./Test/</directory>
 </testsuite>
 </testsuites>
</phpunit>

然后运行：phpunit -c phpunit.xml.dist 就可以了，更多XML配置参考这里。还可以在这基础上更改执行配置，比如phpunit -c phpunit.xml.dist Test/Client/RPCTest，便是依照配置仅运行RPCTest。

以前挺纠结要不要写测试代码，一方面有测试代码的话，每次变更可以自动检测是否通过，另一方面，详细的测试用例需要大量时间去考虑，并且多数情况下都是服务模块之间的互相调用，难以预估结果，超出单元测试范围。现在看来写的这部门测试代码除了验证程序是否准确外，还可以作为示例文档。

参考链接：
PHPUnit: Failed opening required `PHPUnit_Extensions_Story_TestCase.php`
Issues while installing pear.phpunit.de/PHPUnit
单元测试
 “单元测试要做多细？”
我讨厌单元测试：滕振宇谈如何进行单元测试
 自动化单元测试实践之路
 Unit Testing Tutorial Part I: Introduction to PHPUnit

MySQL秒杀优化

Sun, 12 Jul 2015 17:08:24 +0800

今天学习了楼方鑫先生的《基于SQL的秒杀解决方案》，讲解了如何定位和优化秒杀业务中问题。
首先介绍了库存业务，库存可以分为前端库存，后端库存，实体库存。秒杀时，存在的主要问题

库存数据不准确，下单、付款后，得知零库存；超卖或少卖
废单较多，只下单不付款，转化率低
热点商品，拖垮整个站

秒杀过程中，需要解决的技术点包括

余额减一
操作明细，方便追溯对账，防止一个帐号多次参与
完整事务，保障记录明细与扣减库存同时完成
数据落地，内存数据不可靠

针对库存技术要求，做了多个库存解决方案，比如Mysql + Read /Write Cache 。Read Cache方案不足是读有延迟影响用户体验；Write Cache方案存在多个APP写数据不一致性。Mysql + Cache + NoSQL方案则太复杂未实现。

于是又重新回到优化Mysql上。Mysql优势在于事务机制成熟，程序稳定。存在技术难点：单行并发，热点商品，瞬间压力，前一分钟，千万用户，容易堵塞，拖垮网站。于是从以下几个方面进行优化

事务优化，单行更新
并发优化，最大并发数
排队优化，抢同一商品

分析秒杀时的处理逻辑，扫描系统代码，发现大部分程序都在等待确认Update记录数，才提交事务。

开启事务
Insert库存明细
Update库存余额
提交事务

在良好设计下，Mysql的Insert操作，不使用自增列是不会阻塞请求。但是Mysql的Update同一条记录是串行的，需要等远程客户端发送提交命令后才能释放锁，让其他会话继续。简单的更新操作，不考虑IO和锁冲突，一条语句执行的时间大约是0.1ms，一般条件下的网络时延为0.4-0.8ms，即等待事务提交通知的时间比真正SQL执行的时间长数倍。
于是扩展了SQL语法（OneSQL），指定在Update执行完后自动提交，不需要等待客户端发送提交命令，从而节约这一个网络来回的事务等待时间，提升网络性能。

秒杀时如果遇到大量请求需要进行排队，以免太多的请求拖垮Mysql

在应用层排队的缺点，应用需要改造，使用统一框架（需要考虑跨语言)，应用集群扩容时，控制不准确（连接数分配）
在Mysql排队的优点，应用改造极少，只需修改少量SQL语句，无需统一框架，排队精确，发挥InnoDB性能。

于是开发了兼容Mysql的分布式数据访问层（OneProxy），为并发请求进行排队。

另外，还对热点商品进行独立数据库拆分和优化。目前，双十一前商品便已挂出，用户可以收藏或预购，对于商家而言可以准备更多商品；对于平台而言可以预先发现热点商品做优化。

总结，对于业务优化，需要循序渐进，深入了解业务逻辑和技术点，比较不同的解决方案，就算是平常的update操作也有优化空间；同时需要从其他方面进行特定优化，如高并发排队，热点数据分离等。

除了后端数据库优化，对于秒杀抽奖业务，问题的解决核心就是控制单位时间内的流量，使其不超过后端的处理能力。前端的做法包括

分批次（少量多次)进行秒杀
先玩游戏再抢购，如抽奖
随机过滤掉部分请求，仅部分进入系统，如1/10
阈值控制，一旦达到阈值，不再接收新请求
预约排号，未排号用户返回失败（用户分类）
验证码验证

另外，OneProxy 提供的连接池功能对于PHP非常有用。PHP运行在CGI下面，每一个请求到来便需要重新创建一个数据库连接与Mysql进行交互，并发量大量的情况下便会出现：too many connetion，乃至拖垮数据库：mysql server has gone away，影响其他业务。因此Mysql连接池，对于PHP显得非常重要。

更新：小米网在开发抢购系统的时候，最早使用PHP + Mysql碰到了一些问题，例如并发性能，数据一致性，在OneSQL上面都已经做了改进优化，只是小米自己使用Go语言重构，开发大秒系统（BigTap）。

参考链接：
限量秒杀等高并发活动的正确性如何保证？
MySQL 5.6.17/Percona5.6.16/MariaDB 10.0.11/OneSQL 5.6.16 TpmC测试
 由12306.cn谈谈网站性能技术
 “米粉节”背后的故事——小米网抢购系统开发实践
 Web系统大规模并发——电商秒杀与抢购
 OneProxy : 如何给PHP页面以及其他Ruby/Python/Go程序添加连接池功能？
基于Swoole实现的Mysql连接池

PHP ZeroMQ开发

Fri, 10 Jul 2015 17:30:31 +0800

ZeroMQ的名字有点巧妙，看起来是个MQ却加了个0，变得不是MQ。ZeroMQ是一个面向消息传递的网络通信框架，支持程序在进程内部部通信，进程之间通信，网络间通信，多播等。ZeroMQ对Socket进行了封装，支持多种网络结构范式如Request/Reply，Pub/Sub，Pull/Push，中介，路由等，还可以在这些模式再次扩展，动态扩容程序和分布式任务开发，能够轻易搭建服务程序集群。

ZeroMQ与支持AMQP的消息中间件不一样，ZeroMQ是一个网络通信库，需要自行实现中间节点和消息的管理。

在CentOS安装ZeroMQ4

git clone https://github.com/zeromq/zeromq4-x.git
cd zeromq4-x
./autogent.sh
./configure
sudo make
sudo make install

#声明libzmq库的位置
sudo vim /etc/ld.so.conf.d/libzmq.conf
#内容：/usr/local/lib

sudo ldconfig

ZeroMQ支持多种编程语言，也包括PHP。php-zmq安装

git clone https://github.com/mkoppanen/php-zmq.git
cd php-zmq
phpize
./configure
sudo make
sudo make install

sudo vim /etc/php.ini

编辑PHP.ini增加扩展信息

[zeromq]
extension = zmq.so

查看扩展是否加载成功：php -m | grep php。
先写一个简单请求-应答，首先是服务端reply.php

<?php
$pContext = new ZMQContext();
$pServer = new ZMQSocket($pContext, ZMQ::SOCKET_REP);
$pServer->bind("tcp://*:5559");
while (true){
	$strMessage = $pServer->recv();
	echo $strMessage."\r\n";
	$pServer->send("From Server1:".$strMessage);
}

然后是客户端request.php

<?php
$pContext = new ZMQContext();
$pClient = new ZMQSocket($pContext, ZMQ::SOCKET_REQ);
$pClient->connect("tcp://localhost:5559");
$pClient->send("Hello From Client:".uniqid());
var_dump($pClient->recv());

分别在不同终端预先一下程序

#请求者可以先启动
php request.php
#另一个终端
php reply.php

使用ZeroMQ进行通信的步骤

使用ZMQContext创建一个上下文
使用上下文初始化ZMQSocket，这里需要指明socket类型（ZMQ::SOCKET_开头），组合模式包括
- PUB，SUB
- REQ，REP
- REQ，ROUTER (take care, REQ inserts an extra null frame)
- DEALER，REP (take care, REP assumes a null frame)
- DEALER，ROUTER
- DEALER，DEALER
- ROUTER，ROUTER
- PUSH，PULL
- PAIR，PAIR
分类包括
- 轮询，REQ，PUSH，DEALER
- 多播，PUB
- 公平排队，REP，SUB，PULL，DEALER
- 明确寻址，ROUTER
- 单播，PAIR
如果是服务端就bind，如果是客户端就conncet，这里的连接信息支持
- 进程内部通信，inproc://
- 进程间通信，ipc://
- 网络间通信，tcp://
- 多播，pgm://
使用send/recv发送/接收消息

使用ZeroMQ创建通信比socket简单多了，与stream_socket差不多。但是使用ZeroMQ，客户端可以先启动而不用管服务端是否已经启动了，等服务端连接上了便会自动传递消息，还可以维持节点之间的心跳。

ZeroMQ与socket通信是不一样的。ZeroMQ是无状态的，对socket的细节进行了封装，不能知道彼此的socket连接信息，仅能接收和发送消息；ZeroMQ能够使用一个socket与多个节点进行通信，具有极高的性能。

再回头看一下服务端程序，这里采用while循环来处理，亦即同一时刻只能处理一个请求，多个请求排队直到被轮询到，客户端的发送和接收都是同步等待。由于不知道客户端信息，也不能在子进程内处理完成再返回。这里就需要用到ZeroMQ各种范式的组合，比如下面这个

这里使用ROUTER和DEALER作为中介，转发请求，客户端可以异步发送求，不用等待服务端响应。

<?php
$pContext = new ZMQContext();
$pFrontend = new ZMQSocket($pContext, ZMQ::SOCKET_ROUTER);
$pBackend = new ZMQSocket($pContext, ZMQ::SOCKET_DEALER);
$pFrontend->bind("tcp://*:5559");
$pBackend->bind("tcp://*:5560");

$pPoll = new ZMQPoll();
$pPoll->add($pFrontend, ZMQ::POLL_IN);
$pPoll->add($pBackend, ZMQ::POLL_IN);


$arrRead = $arrWrite = array();
while(true){
	$nEvent = $pPoll->poll($arrRead, $arrWrite);
 if ($nEvent > 0) {
		foreach($arrRead as $pSocket){
			if($pSocket === $pFrontend){
				while (true){
					$strMessage = $pSocket->recv();
					$nMore = $pSocket->getSockOpt(ZMQ::SOCKOPT_RCVMORE);
					$pBackend->send($strMessage,$nMore ? ZMQ::MODE_SNDMORE : null);
					if(!$nMore){
						break;
					}
				}
			}
			else if ($pSocket === $pBackend){
				while (true){
					$strMessage = $pSocket->recv();
					$nMore = $pSocket->getSockOpt(ZMQ::SOCKOPT_RCVMORE);
					$pFrontend->send($strMessage,$nMore ? ZMQ::MODE_SNDMORE : null);
					if(!$nMore){
						break;
					}
				}
			}
		}
 }
}

然后更改服务端reply.php，不再绑定监听，而不是连接到DEALER上

<?php
$pContext = new ZMQContext();
$pServer = new ZMQSocket($pContext, ZMQ::SOCKET_REP);
//$pServer->bind("tcp://*:5555");
$pServer->connect("tcp://localhost:5560");
while (true){
	$strMessage = $pServer->recv();
	echo $strMessage."\r\n";
	$pServer->send("From Server1:".$strMessage);
}

这里使用ZMQPoll对ZMQSOcket的输入输出事件进行轮询，将ROUTER收到的REQ转发给服务端，将DEALER收到的REP转发给客户端。事实上，还有更简便的方法：使用ZMQDevice将ROUTER和DEALER组合起来

<?php
$pContext = new ZMQContext();
$pFrontend = new ZMQSocket($pContext, ZMQ::SOCKET_ROUTER);
$pBackend = new ZMQSocket($pContext, ZMQ::SOCKET_DEALER);
$pFrontend->bind("tcp://*:5559");
$pBackend->bind("tcp://*:5560");

$pDevice = new ZMQDevice($pFrontend, $pBackend);
$pDevice->run();

ZeroMQ的Pub/Sub的通信模型支持一个发布者发布消息给多个订阅者，也支持一个订阅者从多个发布者订阅消息。首先写一个发布者

<?php
$pContext = new ZMQContext();
$pPublisher = new ZMQSocket($pContext, ZMQ::SOCKET_PUB);
$pPublisher->bind("tcp://*:5563");

while (true) {
 $pPublisher->send("A", ZMQ::MODE_SNDMORE);
 $pPublisher->send("1:We don't want to see this");
 $pPublisher->send("B", ZMQ::MODE_SNDMORE);
 $pPublisher->send("1:We would like to see this");
 sleep (1);
}

然后是订阅者

$pContext = new ZMQContext();
$pSubscriber = new ZMQSocket($pContext, ZMQ::SOCKET_SUB);
$pSubscriber->connect("tcp://localhost:5563");
#可以连接多个发布者
$pSubscriber->connect("tcp://localhost:5564");
$pSubscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "B");

while (true) {
 // Read envelope with address
 $address = $pSubscriber->recv();
 // Read message contents
 $contents = $pSubscriber->recv();
 printf ("[%s] %s%s", $address, $contents, PHP_EOL);
}

Pub/Sub模型，发布者只能发布消息，要求发布消息前，先声明主题（地址），然后发布消息内容；订阅者只能接收消息，先设置订阅主题，然后两次接收，第一次为消息主题，第二次为消息内容。
Pub/Sub模型通消息为单向流动，可以结合其他模型让订阅者与发布者互动，比如REQ\REP。

ZeroMQ的Push/Pull模型，生产者负责推送消息，消费者负责拉取消息。初看之下Pull/Push模型与Pub/sub模型类似，但是Pull/Push下生产者产生的消息只会投递给一个消费者，并不会发布给全部消费者，适合用于任务投递分配

Push和Pull都既可作为服务端，也可作为客户端。服务端Push.php

<?php
$pContext = new ZMQContext();
$pPush = new ZMQSocket($pContext, ZMQ::SOCKET_PUSH);

$pPush->bind("tcp://*:5558");
//$pPush->connect("tcp://localhost:5558");
//$pPush->connect("tcp://localhost:5559");

$pPush->send("Hello Client 1");

客户端Pull.php

<?php
$pContext = new ZMQContext();
$pPull = new ZMQSocket($pContext, ZMQ::SOCKET_PULL);

//$pPull->bind("tcp://*:5558");
$pPull->connect("tcp://localhost:5558");
$pPull->connect("tcp://localhost:5559");

var_dump($pPull->recv());

如果同时启动了两个客户端Pull.php，而只启动一个服务端Push.php，那么一次只会有一个客户端接收到消息。也可以以Pull作为主动监听，Push作为被动连接。可以同时接可以Pub/Sub和Pull/Push来处理任务

如果是用ZeroMQ传递消息收不到，可以按下面这个流程查问题

除了客户端可以连接多个服务端，服务端同样可以绑定多个地址。在REQ/REP模型里，让服务端同时使用IPC（进程间通信）来处理本机的连接

<?php
$pContext = new ZMQContext();
$pServer = new ZMQSocket($pContext, ZMQ::SOCKET_REP);
$pServer->bind("tcp://*:5556");
$pServer->bind("ipc:///tmp/req.ipc");
while(true){
	$message = $pServer->recv();
	echo $message . PHP_EOL;
	$pServer->send("Hello from server1:".$message);
}

客户端可以选择走TCP或者IPC进行消息通信

<?php
$pContext = new ZMQContext();
$pClient = new ZMQSocket($pContext, ZMQ::SOCKET_REQ);
$pClient->connect("ipc:///tmp/req.ipc");
//$pClient->connect("tcp://localhost:5556");
$pClient->send("Hello From Client1:".uniqid());
$strMessage = $pClient->recv();
echo $strMessage,PHP_EOL;

使用ZeroMQ的进程内部消息通信也很简单

$pServer = new ZMQSocket(new ZMQContext(), ZMQ::SOCKET_REP);
$pServer->bind("inproc://reply");


$pClient = new ZMQSocket(new ZMQContext(), ZMQ::SOCKET_REQ);
$pClient->connect("inproc://reply");;
$pClient->send("Hello From Client1:".uniqid());

var_dump($pServer->recv());

ZeroMQ为消息传递的提供极简的方法，提供了各种连接模型，可以自由扩展。zguide更像是一个网络编程指南，指导大家如何利用ZeroMQ搭建各种网络通信模式，提高程序扩展性和健壮性。虽然ZeroMQ解决了进程间和网络间的通信问题，但是各个组件本身进程控制仍然需要自行实现。

更新：ZeroMQ的作者用C语言创建了另外一个支持多种通用通信范式的socket库：nanomsg，可以用来代替ZeroMQ做的那些事，提供了更好的伸缩性，也有对应的PHP扩展。

参考链接：
ZMQ 指南
 ZeroMQ in PHP
zeromq is the answer
ZeroMQ + libevent in PHP
Europycon2011: Implementing distributed application using ZeroMQ
Getting Started with ‘nanomsg’
A Look at Nanomsg and Scalability Protocols (Why ZeroMQ Shouldn’t Be Your First Choice)

PHP Socket通信

Sun, 05 Jul 2015 23:32:42 +0800

前一篇介绍了跨语言的服务调用框架Thrift，模块与模块之间调用，网络通信必不可少。这里具体介绍下如何使用PHP socket客户端与服务端进行通信。

PHP 的Socket扩展是基于流行的BSD sockets，实现了和socket通讯功能的底层接口，它可以和通用客户端一样当做一个socket服务器。这里的通用客户端是指stream_socket_*系列封装的函数。

首先写一个socket服务端

<?php
class ServerSocket{
	protected $strHost = "127.0.0.1";
	protected $nPort = 2015;
	protected $nProtocol = SOL_TCP;
	protected $pSocket = null;
	protected $pClient = null;

	public $strErrorCode = "";
	public $strErrorMsg = "";
	public function __construct($p_strHost = "127.0.0.1", $p_nPort =2015, $p_nProtocol = SOL_TCP){
		//参数验证
		$this->strHost = $p_strHost;
		$this->nPort = $p_nPort;
		$this->nProtocol = $p_nProtocol;
		if($this->_create()&&$this->_bind()){
			$this->_listen();
		}
	}
	protected function _create(){
		$this->pSocket = socket_create(AF_INET, SOCK_STREAM, $this->nProtocol);
		if(!$this->pSocket){
			$this->_log();
		}
		return $this->pSocket;
	}
	protected function _bind(){
		$bRes = socket_bind($this->pSocket, $this->strHost, $this->nPort);
		if(!$bRes){
			$this->_log();
		}
		return $bRes;
	}
	protected function _listen(){
		$bRes = socket_listen($this->pSocket, 10) ;
		if(!$bRes){
			$this->_log();
		}
		return $bRes;
	}
	public function accept(){
		$this->pClient = socket_accept($this->pSocket);
		if(!$this->pClient){
			$this->_log();
		}
		return $this->pClient;
	}
	protected function _connect(){
		$this->accept();
			
		if(socket_getpeername($this->pClient, $address, $port)){
			echo "Client $address : $port is now connected to us. \n";
		}
		$this->write("hello world from server\n");
	}
	protected function _reply(){
		$mxData = $this->read();
		var_dump($mxData);
		if ($mxData == false) {
			socket_close($this->pClient);

			echo "client disconnected.\n";
			return false;
		}
		else{
			$strMessage = "Client: ".trim($mxData)."\n";
			$this->write($strMessage);
			return true;
		}
	}
	public function run(){
		$this->_connect();
		$this->_reply();
	}
	public function read(){
		$mxMessage = socket_read($this->pClient, 1024, PHP_BINARY_READ);
		if($mxMessage === false){
			$this->_log();
		}
		return $mxMessage;
	}
	public function write($p_strMessage){
		$bRes = socket_write($this->pClient, $p_strMessage, strlen ($p_strMessage));
		if(!$bRes){
			$this->_log();
		}
		return $bRes;
	}
	public function close(){
		$bRes = socket_close($this->pSocket);

		$this->pSocket = null;
	}
	protected function _log(){
		$this->strErrorCode = socket_last_error();
		$this->strErrorMsg = socket_strerror($this->strErrorCode);
		//throw new Exception("exception:".$this->strErrorMsg , $this->strErrorCode);
	}
	public function __destruct(){
		if($this->pSocket){
			$this->close();
		}
	}
}
$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
$pServer = new ServerSocket($strHost, $nPort);
$pServer->run();

这里对socket_*系列函数进行了包装，创建socket服务端的步骤

使用socket_create创建socket（套接字）。第一个参数AF_INET指IPV4网络协议，TCP和UDP均可使用，对应IPV6网络协议为AF_INET6，也可以使用UNIX socket协议AF_UNIX，作进程间通信

。第二个参数对应套接字类型，SOCK_STREAM对应TCP协议使用，SOCK_DGRAM对应UDP协议使用，还有SOCK_SEQPACKET，SOCK_RAW，SOCK_RDM等类型。第三个为协议类型，TCP协议对应常量SOL_TCP，UDP协议对应常量SOL_UDP，其他协议可以从getprotobyname函数获取。

使用socket_bind将套接字绑定到对应的主机端口或者UNIX socket上
使用socket_listen监听该套接字上的连接
使用socket_accept接收套接字上的请求连接，返回一个新的套接字用于与客户端通信。如果没有连接接入，将会阻塞住；如果有多个连接，使用第一个达到的连接。
开始通信，使用socket_read获取请求信息，使用socket_write返回响应结果
使用socket_close关闭连接，包括原始的和socket_accept产生的套接字

这个过程中，可以使用socket_last_error和socket_strerror获取错误信息。接着创建客户端

<?php
class ClientSocket{
	protected $strHost = "127.0.0.1";
	protected $nPort = 2015;
	protected $nProtocol = SOL_TCP;
	private $pSocket = null;
	public $strErrorCode = "";
	public $strErrorMsg = "";

	public function __construct($p_strHost = "127.0.0.1", $p_nPort =2015, $p_nProtocol = SOL_TCP){
		//参数验证
		$this->strHost = $p_strHost;
		$this->nPort = $p_nPort;
		$this->nProtocol = $p_nProtocol;
		if($this->_create()){
			$this->_connect();
		}
	}
	private function _create(){
		$this->pSocket = socket_create(AF_INET, SOCK_STREAM, $this->nProtocol);
		if(!$this->pSocket){
			$this->_log();
		}
		return $this->pSocket;
	}
	private function _connect(){
		$pSocket = $this->_create();
		$bRes = socket_connect($pSocket, $this->strHost, $this->nPort);
		if(!$bRes){
			$this->_log();
		}
		return $bRes;
	}
	public function read(){
		$strMessage = "";
		$strBuffer = "";
		while ($strBuffer = socket_read ($this->pSocket, 1024, PHP_BINARY_READ)) {
			$strMessage .= $strBuffer;
		}
		return $strMessage;
	}
	public function write($p_strMessage){
		$bRes = socket_write($this->pSocket, $p_strMessage, strlen($p_strMessage));
		if(!$bRes){
			$this->_log();
		}
	}
	public function send($p_strMessage){
		$bRes = socket_send($this->pSocket , $p_strMessage , strlen($p_strMessage) , 0);
		if(!$bRes){
			$this->_log();
		}
		return true;
	}
	public function recv(){
		$strMessage = "";
		$strBuffer = "";
		$bRes = socket_recv($this->pSocket, $strBuffer, 1024 , MSG_WAITALL);
		if(!$bRes){
			$this->_log();
		}
		$strMessage .=$strBuffer;
		return $strMessage;
	}
	public function close(){
		$bRes = socket_close($this->pSocket);

		$this->pSocket = null;
	}
	private function _log(){
		$this->strErrorCode = socket_last_error();
		$this->strErrorMsg = socket_strerror($this->strErrorCode);
		//throw new Exception("exception:".$this->strErrorMsg , $this->strErrorCode);
	}
	public function __destruct(){
		if($this->pSocket){
			$this->close();
		}
	}
}

$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
//$nProtocol = getprotobyname($strProtocol);

$pClient = new ClientSocket($strHost, $nPort);

var_dump($pClient->read());
$strMessage = 'Some Thing :'.uniqid();
var_dump($strMessage);
$pClient->write($strMessage);
var_dump($pClient->read());

/*
 var_dump($pClient->recv());
$pClient->send('hello');
var_dump($pClient->recv());
*/
$pClient->close();

客户端的创建步骤:

使用socket_create创建socket套接字，与服务端对应
使用socket_connect连接到服务端的地址或UNIX socket
开始通信，可以使用socket_write和socket_read向套接字写入和读取信息，也可以使用socket_send和socket_recv发送和接收信息
使用socket_close关闭连接

运行服务端程序

php serversocket.php

在另一个终端里运行

[root@vagrant socket]# netstat -apn | grep 25003
tcp 0 0 127.0.0.1:25003 0.0.0.0:* LISTEN 12139/php

如果运行服务端失败，提示 socket_bind(): unable to bind address [98]: Address already in use ，则是端口绑定失败。查看端口占用

[root@vagrant socket]# netstat -apn | grep 25003
tcp 0 0 127.0.0.1:25003 127.0.0.1:36618 TIME_WAIT -

该端口处于TIME_WAIT状态，需要再等一会儿才会释放。这是因为TCP连接关闭需要四次握手，服务端主动关闭了连接，但是未收到客户端发过来的关闭确认，导致处于等待状态，具体原因见火丁笔记《再叙TIME_WAIT》。

如果服务端已经运行成功，在另一个终端里运行客户端程序

php clientsocket.php

这是一个简单服务端/客户端请求应答模型，通常服务端会一直处于监听状态，处理新的请求，重新写一个循环监听的服务端

class SelectServerSocket extends ServerSocket{
	public function run(){
		$this->loop();
	}
	public function loop(){
		$arrRead = array();
		$arrWrite = $arrExp = null;
		$arrClient = array($this->pSocket);
	
		while(true){
			$arrRead = $arrClient;
			if (socket_select($arrRead, $arrWrite, $arrExp, null) < 1){
				continue;
			}
			foreach ($arrRead as $pSocket){
				if($pSocket == $this->pSocket){
					$this->_connect();
						
					$arrClient[] = $this->pClient;
				}
				else{
					$bRes = $this->_reply();
					if($bRes === false){
						$nKey = array_search($this->pClient, $arrClient);
						unset($arrClient[$nKey]);
						continue;
					}
				}
	
			}
		}
		//usleep(100);
	}
}
$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
$pServer = new SelectServerSocket($strHost, $nPort);
$pServer->run();

在循环里面使用socket_select查询有可以读的套接字，如果套接字为原始监听的套接字，则使用socket_accept获取新接入的通信套接字进行通信；如果是通信套接字，则与客户端进行交互。

这里socket_select($arrRead, $arrWrite, $arrExp, null)的第四个参数为null，表示可以无限阻塞，如果为0则不阻塞立即返回，其他大于0值则等待超时。
socket_recv($this->pSocket, $strBuffer, 1024 , MSG_WAITALL)的第四个参数为MSG_WAITALL，表示阻塞读取结果。
socket_read ($this->pSocket, 1024, PHP_BINARY_READ )的第三个参数PHP_BINARY_READ表示读取以\0结束，PHP_NORMAL_READ表示读取以\n或\r结束

在终端里运行服务端，会一直在那里等待新的连接。这时候运行客户端，客户端确也阻塞住了。解决的办法有两种：超时设置和非阻塞设置。给ClientSocket类增加超时和阻塞设置的方法

	public function setTimeOut($p_nSendTimeOut = 1, $p_nRecvTimeOut = 1){
		$nSend = (int)$p_nSendTimeOut;
		$nRecv = (int)$p_nRecvTimeOut;

		$arrSend = array('sec' => $nSend, 'usec' => (int)(($p_nSendTimeOut - $nSend) * 1000 * 1000));
		$arrRecv = array('sec' => $nRecv, 'usec' => (int)(($p_nRecvTimeOut - $nRecv) * 1000 * 1000));

		socket_set_option($this->pSocket, SOL_SOCKET, SO_RCVTIMEO, $arrSend);
		socket_set_option($this->pSocket, SOL_SOCKET, SO_SNDTIMEO, $arrRecv);
	}
	public function setBlock($p_bType = true){
		if($p_bType){
			socket_set_block($this->pSocket);
		}
		else{
			socket_set_nonblock($this->pSocket);
		}
	}

客户端端运行前，先设置一下超时或非阻塞即，此时程序不会再阻塞了

$pClient = new ClientSocket($strHost, $nPort);

$pClient->setTimeOut(1, 1);
//$pClient->setBlock(false);

//do request here

同样在服务端设置超时和非阻塞也是可以的，给ServerSocket增加超时和非阻塞设置的方法

	protected function _setNoBlock($p_pSocket){
		socket_set_nonblock($p_pSocket);
	}
	protected function _setTimeOut($p_pSocket, $p_nSendTimeOut = 1, $p_nRecvTimeOut = 1){
		$nSend = (int)$p_nSendTimeOut;
		$nRecv = (int)$p_nRecvTimeOut;

		$arrSend = array('sec' => $nSend, 'usec' => (int)(($p_nSendTimeOut - $nSend) * 1000 * 1000));
		$arrRecv = array('sec' => $nRecv, 'usec' => (int)(($p_nRecvTimeOut - $nRecv) * 1000 * 1000));

		socket_set_option($p_pSocket, SOL_SOCKET, SO_RCVTIMEO, $arrSend);
		socket_set_option($p_pSocket, SOL_SOCKET, SO_SNDTIMEO, $arrRecv);
	}

将SelectServerSocket的socket_accept后产生的连接设置为非阻塞

	public function loop(){
		$arrRead = array();
		$arrWrite = $arrExp = null;
		$arrClient = array($this->pSocket);
		$this->_setNoBlock($this->pSocket);
	
		while(true){

再次运行服务端，客户端也不会阻塞了。

在while循环里面使用socket_select进行查询，效率比较低下，有先的连接要等下次循环才能处理；有时候并没有连接需要处理，也一直在循环。可以结合前面介绍过的PHP Libev扩展进行监听

class EvServerSocket extends ServerSocket{
	protected function _onConnect(){
		$this->_connect();
	
		$pReadClient = new EvIo($this->pClient, Ev::READ, function ($watcher, $revents) {
			$this->_reply();
		});
		Ev::run();
	}
	public function run(){
		$pReadWatcher = new EvIo($this->pSocket, Ev::READ, function ($watcher, $revents) {
			$this->_onConnect();
		});
		Ev::run();
	}
}

$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
$pServer = new EvServerSocket($strHost, $nPort);
$pServer->run();

代码看起来简单了很多。当原始套接字监听到可读事件时，便为新的套接字也创建可读事件监听，在事件里面处理新的连接。

通常的服务端程序是一个进程监听原始套接字，然后交由其他进程/线程处理新的连接套接字，与客户端进行交互，提升服务端性能。这样子又涉及到了多进程/多线程的控制、通信，需要一套完善的体系才行。


class MulProcessServerSocket extends EvServerSocket{
	protected function _execute(){
		if(!$this->_reply()){
			//子进程执行完毕，通知父进程
			exit();
		}
	}
	protected function _onConnect(){
		$pid = pcntl_fork();
		//父进程和子进程都会执行下面代码
		if ($pid == -1) {
			//错误处理：创建子进程失败时返回-1.
			die('could not fork');
		} else if ($pid) {
			//父进程会得到子进程号，所以这里是父进程执行的逻辑
			pcntl_wait($status); //等待子进程中断，防止子进程成为僵尸进程。
		} else {
			//子进程得到的$pid为0, 所以这里是子进程执行的逻辑。
			$this->_connect();

			$pReadClient = new EvIo($this->pClient, Ev::READ, function ($watcher, $revents) {
				$this->_execute();
			});
			Ev::run();
		}

	}
}

还可以使用stream_socket_*系列函数来创建sockt服务端和客户端。类似的创建一个客户端与之前的服务端进行交互

<?php
class ClientStreamSocket{
	private $pConnetion = null;
	protected $strAddress = "tcp://127.0.0.1:2016";
	protected $nTimeOut = 3;
	protected $nFlag = STREAM_CLIENT_CONNECT;
	public $strErrorCode = "";
	public $strErrorMsg = "";
	const BLOCK = 1;
	const NOBLOCK = 0;
	public function __construct($p_strAddress, $p_nTimeOut = 3, $p_nFlag = STREAM_CLIENT_CONNECT){
		$this->strAddress = $p_strAddress;
		$this->nTimeOut = $p_nTimeOut;
		$this->nFlag = $p_nFlag;
		$this->_connect();
	}
	private function _connect(){
		$this->pConnetion = stream_socket_client($this->strAddress, $this->strErrorCode, $this->strErrorMsg, $this->nTimeOut, $this->nFlag);
		if(!$this->pConnetion){
			throw new Exception("connect exception:".$this->strErrorMsg, $this->strErrorCode);
		}
		return $this->pConnetion;
	}
	public function write($p_strMessage){
		if(fwrite($this->pConnetion, $p_strMessage) !== strlen($p_strMessage))
		{
			throw new Exception('Can not send data');
		}
		return true;
	}
	public function read(){
		//接收一行，阻塞至\n结束
		//$strMessage = fgets($this->pConnetion);
		//指定长度读取
		//$strMessage = fread($this->pConnetion, 1024);
		$strMessage = stream_socket_recvfrom($this->pConnetion, 1024);
		//$strMessage = stream_get_contents($this->pConnetion);

		return $strMessage;
	}
	public function close(){
		fclose($this->pConnetion);
		$this->pConnetion = null;
	}
	public function setContext(){

	}
	public function setTimeOut($p_nTimeOut = 1){
		$bRes = stream_set_timeout($this->pConnetion, $p_nTimeOut);
	}
	public function setBlock($p_nMode = ClientStreamSocket::BLOCK){
		$bRes = stream_set_blocking($this->pConnetion, $p_nMode);
	}
	public function __destruct(){
		if($this->pConnetion){
			$this->close();
		}
	}
}

$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
//$nProtocol = getprotobyname($strProtocol);

$strAddress = $strProtocol."://".$strHost.":".$nPort;

$pStream = new ClientStreamSocket($strAddress);
//$pStream->setBlock(ClientStreamSocket::NOBLOCK);
//$pStream->setTimeOut(1);
var_dump($pStream->read());
$pStream->write("hello from client\n");
var_dump($pStream->read());
$pStream->close();

使用stream_socket_*系列函数创建客户端要简单不少

首先使用stream_socket_client创建一个socket操作流(stream)
然后就可以像操作流式文件那样造成socket stream，使用fread和fwrite进行读写操作，也可以使用stream_socket_recvfrom和stream_socket_sendto进行操作
使用fclose或stream_socket_shutdown关闭连接

使用stream_socket_*系列函数创建一个服务端来与之前的客户端进行交互，同样很简单，也与ServerSocket类似

<?php
class ServerStreamSocket{
	protected $pServer = null;
	protected $pClient = null;
	protected $strAddress = "tcp://127.0.0.1:2016";
	protected $nFlag = STREAM_SERVER_LISTEN;
	
	const BLOCK = 1;
	const NOBLOCK = 0;
	
	public $strErrorCode = "";
	public $strErrorMsg = "";
	public function __construct($p_strAddress, $p_nFlag = STREAM_SERVER_LISTEN){
		$this->strAddress = $p_strAddress;
		$this->nFlag = $p_nFlag;
		$this->_create();
	}
	protected function _create(){
		$this->pServer = stream_socket_server($this->strAddress, $this->strErrorCode, $this->strErrorMsg);
		if(!$this->pServer ){
			throw new Exception("create exception:".$this->strErrorMsg, $this->strErrorCode);
		}
		return $this->pServer ;
	}
	public function accept(){
		$this->pClient = stream_socket_accept($this->pServer);
		if(!$this->pClient ){
			return false;
		}
		return $this->pClient ;
	}
	protected function _connect(){
		$this->accept();
		echo "Client". stream_socket_get_name($this->pClient, true)." is now connected to us. \n";
		$this->write("hello world from server\n");
	}
	protected function _reply(){
		$mxData = $this->read();
		var_dump($mxData);
		if($mxData == false){
			fclose($this->pClient);
				
			echo "client disconnected.\n";
			return false;
		}
		else{
			$strMessage = "Client:".trim($mxData)."\n";
			$this->write($strMessage);
			return true;
		}
	}
	public function run(){
		$this->_connect();
		$this->_reply();
	}
	public function write($p_strMessage){
		//$nLen = fwrite($this->pClient, $p_strMessage);
		$nLen = stream_socket_sendto($this->pClient, $p_strMessage);
		if($nLen !== strlen($p_strMessage))
		{
			throw new Exception('Can not send data');
		}
		return true;
	}
	public function read(){
		//接收一行，阻塞至\n结束
		//$strMessage = fgets($this->pClient);
		//指定长度读取
		//$strMessage = fread($this->pClient, 1024);
		$strMessage = stream_socket_recvfrom($this->pClient, 1024);
		//$strMessage = stream_get_contents($this->pClient);

		return $strMessage;
	}
	public function close(){
		fclose($this->pServer);
		
		$this->pServer = null;
	}
	public function setContext(){

	}
	public function setTimeOut($p_pConnetction, $p_nTimeOut = 1){
		$bRes = stream_set_timeout($p_pConnetction, $p_nTimeOut);
	}
	public function setBlock($p_pConnetction, $p_nMode = ServerStreamSocket::BLOCK){
		$bRes = stream_set_blocking($p_pConnetction, $p_nMode);
	}
	public function __destruct(){
		if($this->pServer){
			$this->close();
		}
	}
}
class SelectServerStreamSocket extends ServerStreamSocket{
	public function run(){
		$this->loop();
	}
	public function loop(){
		$arrRead = array();
		$arrWrite = $arrExp = null;
		$arrClient = array($this->pServer);
		while(true){
			$arrRead = $arrClient;
			if (stream_select($arrRead, $arrWrite, $arrExp, null) < 1){
				continue;
			}
			if(in_array($this->pServer, $arrRead)){
				$this->_connect();
	
				$arrClient[] = $this->pClient;
	
				$nKey = array_search($this->pServer, $arrRead);
				unset($arrRead[$nKey]);
			}
			foreach($arrRead as $pConnetcion){
				$bRes = $this->_reply();
				if($bRes === false){
					$nKey = array_search($this->pClient, $arrClient);
					unset($arrClient[$nKey]);;
					continue;
				}
			}
		}
		//usleep(100);
	}
}
class EvServerStreamSocket extends ServerStreamSocket{
	protected function _onConnect(){
		$this->_connect();
		
		$pReadClient = new EvIo($this->pClient, Ev::READ, function ($watcher, $revents) {
			$this->_reply();
		});
		Ev::run();
	}
	public function run(){
		$pReadWatcher = new EvIo($this->pServer, Ev::READ, function ($watcher, $revents) {
			$this->_onConnect();
		});
		Ev::run();
	}
}
class MulProcessServerStreamSocket extends EvServerStreamSocket{
	protected function _execute(){
		if(!$this->_reply()){
			//子进程执行完毕，通知父进程
			exit();
		}
	}
	protected function _onConnect(){
		$pid = pcntl_fork();
		if ($pid == -1) {
			die('could not fork');
		} else if ($pid) {
			pcntl_wait($status);
		} else {
			$this->_connect();

			$pReadClient = new EvIo($this->pClient, Ev::READ, function ($watcher, $revents) {
				$this->_execute();
			});
			Ev::run();
		}

	}
}
$strHost = "127.0.0.1";
$nPort = 25003;
$strProtocol = "tcp";
//$nProtocol = getprotobyname($strProtocol);

$strAddress = $strProtocol."://".$strHost.":".$nPort;

$pServer = new EvServerStreamSocket($strAddress);

$pServer->run();

这里演示客户端与服务端交互，都是两步走，先发送一个请求再获取结果。在Thrift RPC远程调用中，既可先发送请求，过一会儿再来获取结果，达到异步交互的目的；也可发送完请求后立即获取结果，达到同步请求的目的。

参考链接：
Socket Programming in PHP
Socket programming with streams in php
PHP Socket programming tutorial
php 实例说明 socket通信机制
 Mpass – PHP做Socket服务的解决方案
 How to forcibly close a socket in TIME_WAIT?

PHP RPC开发之Thrift

Sun, 28 Jun 2015 13:38:47 +0800

Apache Thrift是一个跨语言的服务部署框架，通过一个中间语言(IDL, 接口定义语言)来定义RPC的接口和数据类型，然后通过一个编译器生成不同语言的代码（支持C++，Java，Python，PHP, GO，Javascript，Ruby，Erlang，Perl， Haskell， C#等）,并由生成的代码负责RPC协议层和传输层的实现。

在CentOS 6.5上安装Thrift

sudo yum -y update
sudo yum -y groupinstall "Development Tools"

#升级autoconf，必须2.65以上
wget http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz
tar xvf autoconf-2.69.tar.gz
cd autoconf-2.69
./configure --prefix=/usr
make
sudo make install
cd ..

#升级automake必须1.14以上
wget http://ftp.gnu.org/gnu/automake/automake-1.14.tar.gz
tar xvf automake-1.14.tar.gz
cd automake-1.14
./configure --prefix=/usr
make
sudo make install
cd ..

#升级bsion
wget http://ftp.gnu.org/gnu/bison/bison-2.5.1.tar.gz
tar xvf bison-2.5.1.tar.gz
cd bison-2.5.1
./configure --prefix=/usr
make
sudo make install
cd ..

#安装boost
wget http://sourceforge.net/projects/boost/files/boost/1.55.0/boost_1_55_0.tar.gz
tar xvf boost_1_55_0.tar.gz
cd boost_1_55_0
./bootstrap.sh
sudo ./b2 install
cd ..

#安装thrift，编译会比较久，内存最好1024M以上
git clone https://git-wip-us.apache.org/repos/asf/thrift.git
cd thrift
./bootstrap.sh
./configure
make
sudo make install
cd ..

#查看版本
thrift -version

#安装thrift_protocol扩展，仅支持二进制读写
cd thrift/lib/php/src/ext/thrift_protocol
phpize
./configure
sudo make
sudo make install
#这里不需要更改php.ini，已自动在/etc/php.d/thrift_protocol.ini里面添加
php -m | grep thrift

Thrift的PHP类库位于thrift/lib/php/lib/Thrift目录下面，Thrift对于数据传输格式、数据传输方式，服务器模型均做了定义，方便自行扩展。

数据传输格式（protocol）是定义的了传输内容，对Thrift Type的打包解包，包括

TBinaryProtocol，二进制格式，TBinaryProtocolAccelerated则是依赖于thrift_protocol扩展的快速打包解包。
TCompactProtocol，压缩格式
TJSONProtocol，JSON格式
TMultiplexedProtocol，利用前三种数据格式与支持多路复用协议的服务端（同时提供多个服务，TMultiplexedProcessor）交互

数据传输方式（transport），定义了如何发送（write）和接收（read）数据，包括

TBufferedTransport，缓存传输，写入数据并不立即开始传输，直到刷新缓存。
TSocket，使用socket传输
TFramedTransport，采用分块方式进行传输，具体传输实现依赖其他传输方式，比如TSocket
TCurlClient，使用curl与服务端交互
THttpClient，采用stream方式与HTTP服务端交互
TMemoryBuffer，使用内存方式交换数据
TPhpStream，使用PHP标准输入输出流进行传输
TNullTransport，关闭数据传输
TSocketPool在TSocket基础支持多个服务端管理（需要APC支持），自动剔除无效的服务器
TNonblockingSocket，非官方实现非阻塞socket

服务模型，定义了当PHP作为服务端如何监听端口处理请求

TForkingServer，采用子进程处理请求
TSimpleServer，在TServerSocket基础上处理请求
TNonblockingServer，基于libevent的非官方实现非阻塞服务端，与TNonblockingServerSocket，TNonblockingSocket配合使用

另外还定义了一些工厂，以便在Server模式下对数据传输格式和传输方式进行绑定

TProtocolFactory，数据传输格式工厂类，对protocol的工厂化生产，包括TBinaryProtocolFactory，TCompactProtocolFactory，TJSONProtocolFactory
TTransportFactory，数据传输方式工厂类，对transport的工厂化生产，作为server时，需要自行实现
TStringFuncFactory，字符串处理工厂类

其他文件便是异常，字符串处理，自动加载器的定义等等。

现在开始编写一个简单接IDL文件HelloWorld.thrift

namespace php Services.HelloWorld
service HelloWorld
{
 string sayHello(1:string name);
}

然后通过生成器生成PHP文件

#不指明:server不生成processor。。
thrift --gen php:server HelloWorld.thrift

生成文件在gen-php目录下面的Services/HelloWord/HelloWorld.php（目录与namesapce定义一致），这是个公共文件，服务端和客户端都需要包括它。其中客户端调用的代码（HelloWorldClient ）已经生成好了

//服务端需要继承该接口
interface HelloWorldIf {
 /**
 * @param string $name
 * @return string
 */
 public function sayHello($name);
}
//提供给客户端调用的方法
class HelloWorldClient implements \Services\HelloWorld\HelloWorldIf {
 public function sayHello($name)
 {
 $this->send_sayHello($name);
 return $this->recv_sayHello();
 }
 public function send_sayHello($name)
 {
 }
 public function recv_sayHello()
 {
 }
}
//HelloWord类sayHello方法参数读取
class HelloWorld_sayHello_args {
}
//HelloWord类sayHello方法结果写入
class HelloWorld_sayHello_result {
}
//作为服务端才会生成
class HelloWorldProcessor {
}

而服务端的服务实现代码则需要继承HelloWorldIf 实现代码HelloWorldHandler.php

<?php
namespace Services\HelloWorld;

class HelloWorldHandler implements HelloWorldIf {
 public function sayHello($name)
 {
 return "Hello $name";
 }
}

编写服务端代码Server.php

<?php
namespace Services\HelloWorld;

error_reporting(E_ALL);

define('THRIFT_ROOT', __DIR__.'/../../../');
require_once THRIFT_ROOT.'Thrift/ClassLoader/ThriftClassLoader.php';

use Thrift\ClassLoader\ThriftClassLoader;

$loader = new ThriftClassLoader();
$loader->registerNamespace('Thrift', THRIFT_ROOT);
$loader->registerDefinition('Service', THRIFT_ROOT.'/gen-php');
$loader->register();

use Thrift\Exception\TException;
use Thrift\Factory\TBinaryProtocolFactory;
use Thrift\Factory\TBufferedTransportFactory;

use Thrift\Server\TServerSocket;
use Thrift\Server\TSimpleServer;

//use Thrift\Server\TNonblockingServerSocket;
//use Thrift\Server\TNonblockingServer;

//use Thrift\Protocol\TBinaryProtocol;
//use Thrift\Transport\TPhpStream;
//use Thrift\Transport\TBufferedTransport;


try {
	require_once 'HelloWorldHandler.php';
	$handler = new \Services\HelloWorld\HelloWorldHandler();
	$processor = new \Services\HelloWorld\HelloWorldProcessor($handler);
	
	$transportFactory = new TBufferedTransportFactory();
	$protocolFactory = new TBinaryProtocolFactory(true, true);
	
	//作为cli方式运行，监听端口，官方实现
	$transport = new TServerSocket('localhost', 9090);
	$server = new TSimpleServer($processor, $transport, $transportFactory, $transportFactory, $protocolFactory, $protocolFactory);
	$server->serve();
	
	//作为cli方式运行，非阻塞方式监听，基于libevent实现，非官方实现
	//$transport = new TNonblockingServerSocket('localhost', 9090);
	//$server = new TNonblockingServer($processor, $transport, $transportFactory, $transportFactory, $protocolFactory, $protocolFactory);
	//$server->serve();

	//客户端和服务端在同一个输入输出流上
	//使用方式
	//1) cli 方式：php Client.php | php Server.php 
	//2) cgi 方式：利用Apache或nginx监听http请求，调用php-fpm处理，将请求转换为PHP标准输入输出流
	//$transport = new TBufferedTransport(new TPhpStream(TPhpStream::MODE_R | TPhpStream::MODE_W));
	//$protocol = new TBinaryProtocol($transport, true, true);
	//$transport->open();
	//$processor->process($protocol, $protocol);
	//$transport->close();
	
} catch (TException $tx) {
	print 'TException: '.$tx->getMessage()."\n";
}

服务端创建的步骤：

首先初始化服务提供者handler
然后利用该handler初始化自动生成的processor
初始化数据传输方式transport
利用该传输方式初始化数据传输格式protocol
开始服务

编写客户端代码Client.php

<?php
namespace Services\HelloWorld;

error_reporting(E_ALL);

define('THRIFT_ROOT', __DIR__.'/../../../');
require_once THRIFT_ROOT.'Thrift/ClassLoader/ThriftClassLoader.php';

use Thrift\ClassLoader\ThriftClassLoader;

$loader = new ThriftClassLoader();
$loader->registerNamespace('Thrift', THRIFT_ROOT);
$loader->registerDefinition('Service', THRIFT_ROOT.'/gen-php');
$loader->register();

//use Thrift\Transport\TPhpStream;

use Thrift\Protocol\TBinaryProtocol;
use Thrift\Transport\TSocket;
use Thrift\Transport\TBufferedTransport;
use Thrift\Exception\TException;

try {
	//仅在与服务端处于同一输出输出流有用
	//使用方式：php Client.php | php Server.php 
	//$transport = new TBufferedTransport(new TPhpStream(TPhpStream::MODE_R | TPhpStream::MODE_W));
	
	//socket方式连接服务端
	//数据传输格式和数据传输方式与服务端一一对应
	//如果服务端以http方式提供服务，可以使用THttpClient/TCurlClient数据传输方式
	$transport = new TBufferedTransport(new TSocket('localhost', 9090));
	$protocol = new TBinaryProtocol($transport);
	$client = new \Services\HelloWorld\HelloWorldClient($protocol);

	$transport->open();
	
	//同步方式进行交互
	$recv = $client->sayHello('Courages');
	echo "\n sayHello11dd:".$recv." \n";
	
	//异步方式进行交互
	$client->send_sayHello('Us');
	echo "\n send_sayHello \n";
	$recv = $client->recv_sayHello();
	echo "\n recv_sayHello:".$recv." \n";
	
	$transport->close();
} catch (TException $tx) {
	print 'TException: '.$tx->getMessage()."\n";
}

客户端调用的步骤：

初始化数据传输方式transport，与服务端对应
利用该传输方式初始化数据传输格式protocol，与服务端对应
实例化自动生成的Client对象
开始调用

在终端上运行

#以cli方式运行TPhpStream 
#php Client.php | php Server.php

#先运行Server.php
#要不然会报错：TException: TSocket: Could not connect to localhost:9090 (Connection refused [111])
php Server.php

#在另外一个终端运行
php Client.ph

官方给的例子，PHP作为服务端是以web方式进行提供的，在cli方式下并不能运行。

Thrift作为一个跨语言的服务框架，方便不同语言、模块之间互相调用，解耦服务逻辑代码，拓展了PHP的处理能力（如与Hbase交互），使得WEB架构更具弹性。与基于 SOAP 消息格式的 Web Service和基于 JSON 消息格式的 RESTful 服务不同，Thrif数据传输格式默认采用二进制传格式，对 XML 和 JSON 体积更小，但对于服务端的CPU占用比JSON、XML要高。PHP虽然有thrift_protocol扩展，但仅仅作为二进制数据传输格式化使用，其他文件的加载仍然为PHP，需要更多的开销。

如果由PHP来做为Thrift的服务端，仅仅这样子做仍然是不够的，Thrift仅仅实现的数据定义和传输，未实现RPC架构

需要避免重复加载各类文件，是否做成PHP扩展
数据传输格式和方式是否适需要自行扩展
客户端要能够自动连可使用的服务端，剔除失效的服务器
服务端需要处理客户端并发情况，是否多进程/异步处理
服务端需要监控服务是否正常

workerman-thrift-rpc对这些问题进行了解决，基于thrift提供了一个可靠性的RPC框架。对客户端和服务端的调用做了封装，提供统一入口，利用workerman做socket中转，当客户端发出请求时，将给socket转给服务端使用，提供服务。workerman-json-rpc与workerman-thrift-rpc类似，采用异步（分步）收发，但简单多了，更像是一种约定。数据格式，发送时仅发送class，function，parameters三个参数，接收时，仅code，msg，data三个返回值，在格式约束及跨语言上，需要自行处理；不需要thrift那样依赖于生成器所生成的文件，客户端完全独立于服务端。

注：以上示例使用修改过的代码，附上代码：thrift。

参考链接：
Apache Thrift – 可伸缩的跨语言服务开发框架
 Thirft框架介绍
 Apache Thrift
Building Apache Thrift on CentOS 6.5
PHP Tutorial
Creating a public API with Apache Thrift
hadoop + Hbase + thrift + php 安裝設定與程式設計
 php实现的thrift socket server
Our own “Hello World!”

PHP 事件驱动开发

Fri, 26 Jun 2015 20:00:58 +0800

最近在学习PHP的系统事件驱动（event-base）开发，发现PHP有好几个event扩展，根据底层库依赖分为两类：libevent和libev。libevent可以为文件描述符、信号、超时设定等事件提供了监听回调，支持poll/kqueue/event port/select/epoll。libevent 库的其他组件提供其他功能，包括缓冲的事件系统（用于缓冲发送到客户端/从客户端接收的数据）以及 HTTP、DNS 和 RPC 系统的核心实现。libev提供了各种监听器，包括子进程监听，超时设定，定时器，IO监听，信号监听，文件监视等，支持epoll/kqueue/event ports/inotify/eventfd/signalfd，更快的时钟管理，时间变化检测和修正。PHP依赖libevent扩展有libevent，event，PHP依赖libev扩展则有Ev，libev。

libevent在PHP事件驱动开发上应用广泛，比如workerman，phpDaemon，ReactPHP，Kellner。CentOS上PHP 5.4安装libevent扩展

sudo yum install libevent-devel

wget https://pecl.php.net/get/libevent-0.1.0.tgz
tar -zxvf libevent-0.1.0.tgz
cd libevent-0.1.0
phpize 
./configure
sudo make
sudo make install

#增加libevent.so
sudo vim /etc/php.ini

#是否安装成功
php -m | grep libevent

前面介绍过使用ticks和pcntl_signal来做定时器，然而tick运行机制是PHP解释器每执行 N 条可计时的低级语句就会发生的事件，如果tick值设置小了，会产生频繁的系统调用，设置大了又不能保证及时。使用libevent来设置一个定时器

<?php
function print_dot(){
	echo ".";
}

class Timer{
	protected $pEventBase;
	protected $pEvent;
	public $nInterval = 1;
	public function __construct(){
		$this->pEventBase = event_base_new();
	}
	public function addEvent($p_pFunc, $p_mxArgs = null){
		$this->pEvent = event_new();
		event_set($this->pEvent, 0, EV_TIMEOUT, $p_pFunc, $p_mxArgs);
		event_base_set($this->pEvent, $this->pEventBase);
	}
	public function loop(){
		event_add($this->pEvent, $this->nInterval*1000000);
		event_base_loop($this->pEventBase);
	}
}

$pTimer = new Timer();
$pTimer->addEvent("print_dot");
while(1){
	$pTimer->loop();
}

libevent使用也很简单：

使用event_base_new和event_new分别创建event_base和event
使用event_set为event设置要监听文件描述符fd，比如文件、socke、信号，超时则fd为0，事件类型和回调函数
使用event_base_set关联event_base和event
使用event_add将设置好的event加入事件监听器
调用event_base_loop开始处理事件

官网上有个例子用来做socket监听处理

<?php
$socket = stream_socket_server ('tcp://0.0.0.0:2000', $errno, $errstr);
stream_set_blocking($socket, 0);
$base = event_base_new();
$event = event_new();
event_set($event, $socket, EV_READ | EV_PERSIST, 'ev_accept', $base);
event_base_set($event, $base);
event_add($event);
event_base_loop($base);

$GLOBALS['connections'] = array();
$GLOBALS['buffers'] = array();

function ev_accept($socket, $flag, $base) {
 static $id = 0;
 
 $connection = stream_socket_accept($socket);
 stream_set_blocking($connection, 0);
 
 $id += 1;
 
 $buffer = event_buffer_new($connection, 'ev_read', NULL, 'ev_error', $id);
 event_buffer_base_set($buffer, $base);
 event_buffer_timeout_set($buffer, 30, 30);
 event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
 event_buffer_priority_set($buffer, 10);
 event_buffer_enable($buffer, EV_READ | EV_PERSIST);
 
 // we need to save both buffer and connection outside
 $GLOBALS['connections'][$id] = $connection;
 $GLOBALS['buffers'][$id] = $buffer;
}

function ev_error($buffer, $error, $id) {
 event_buffer_disable($GLOBALS['buffers'][$id], EV_READ | EV_WRITE);
 event_buffer_free($GLOBALS['buffers'][$id]);
 fclose($GLOBALS['connections'][$id]);
 unset($GLOBALS['buffers'][$id], $GLOBALS['connections'][$id]);
}

function ev_read($buffer, $id) {
 while ($read = event_buffer_read($buffer, 256)) {
 var_dump($read);
 }
}

相比libevent，event扩展提供了面向对象的方法，支持libevent 2+ 的特性，对HTTP，DNS，OpenSSL等协议操作进行封装。Kellner框架比较有意思，在PHP的libevent扩展基础上将http请求处理封装成了扩展，使用cli模式处理http请求，并给出了基于Zend Framework 2的示例。

libev自称libevent的替代者，克服了libevent的一些不利影响，开销更小，Node JS便是利用它来做事件驱动。相比基于libeventd的扩展，基于libev的ev扩展更新比较积极，支持设置各种的监听器，为感兴趣的事件注册回调，比如文件变化，超时。CentOS上PHP 5.4安装ev扩展

wget https://pecl.php.net/get/ev-0.2.15.tgz
tar -zxvf ev-0.2.15
cd ev-0.2.15
phpize 
./configure
sudo make
sudo make install

#增加ev.so
sudo vim /etc/php.ini

#是否安装成功
php -m | grep ev

libev封装了各种监视器，操作也比较简单。

<?php
/**
 * 延迟1秒后执行，不重复
 */
$pDelay = new EvTimer(1, 0, function () {
	echo "1 delay \n";
});
/**
 * 每隔一秒执行一次的定时器，0秒后执行
 */
$pTimer = new EvTimer(0, 1, function () {
	echo "1 seconds \n";
});
/**
 * 如果没有其他更高等级的监视器，那么就执行EvIdle，处于低优先级则不执行
 */
$pIdle = new EvIdle(function(){
	sleep(1);
	echo "idle timer \n";
},0,2);
/**
 * 每一次loop开始都会执行
 */
$pPrepare = new EvPrepare(function(){
	echo "before timer \n";
},0);
/**
 * 每一次loop都会执行，可以通过优先级调整执行顺序
 */
$c = new EvCheck(function(){
	echo "after timer \n";
},0,-1);
/**
 * 定时器，每隔1.5秒后执行一次，0秒后开始
 */
$pPeriod = new EvPeriodic(0., 1.5, NULL, function ($w, $revents) {
	echo time(), PHP_EOL;
});
/**
 * IO输入事件监听，可以拿去监听socket的Ev::WRITE和Ev::READ事件
 */
$pReadWatcher = new EvIo(STDIN, Ev::READ, function ($watcher, $revents) {
	echo "STDIN is readable\n";
});

/**
 * 注册监听感兴趣的信号
 */
$pSignal = new EvSignal(SIGTERM, function ($watcher) {
	echo "SIGTERM received\n";
	$watcher->stop();
});
/**
 * 文件变化监听器，10秒监测一次
 */
$pStatWatcher = new EvStat("/var/log/messages", 10, function ($w) {
	echo "/var/log/messages changed\n";
	
	$attr = $pStatWatcher->attr();
	
	if ($attr['nlink']) {
		printf("Current size: %ld\n", $attr['size']);
		printf("Current atime: %ld\n", $attr['atime']);
		printf("Current mtime: %ld\n", $attr['mtime']);
	} else {
		fprintf(STDERR, "`messages` file is not there!");
		$pStatWatcher->stop();
	}
});
	
/**
 * 开始执行Ev::RUN_ONCE则立即执行Ev::RUN_NOWAIT则非阻塞执行
 */
Ev::run();

也可以监听子进程

$pid = pcntl_fork();

if ($pid == -1) {
 fprintf(STDERR, "pcntl_fork failed\n");
} elseif ($pid) {
 $w = new EvChild($pid, FALSE, function ($w, $revents) {
 $w->stop();

 printf("Process %d exited with status %d\n", $w->rpid, $w->rstatus);
 });

 Ev::run();

 // Protect against Zombies
 pcntl_wait($status);
} else {
 //Forked child
 exit(2);
}

php的libev扩展也实现了libev的所有监视器，提供类似的用法，但比较久没更新了。

在网络编程中，使用事件驱动模型监听感兴趣的事件，结合异步处理，能够大大提高服务器性能。传统服务器模型如Apache为每一个请求生成一个子进程。当用户连接到服务器的一个子进程就产生，并处理连接。每个连接获得一个单独的线程和子进程。当用户请求数据返回时，子进程开始等待数据库操作返回。如果此时另一个用户也请求返回数据，这时就产生了阻塞。以下引用自《使用事件驱动模型实现高效稳定的网络服务器程序》

简单网络编程模型里面，服务器与客户端都是一应一答，大部分的 socket 接口都是阻塞型的。在面对多个客户端的请求时候，最简单的解决方式是在服务器端使用多线程（或多进程）。如果要同时响应成百上千路的连接请求，则无论多线程还是多进程都会严重占据系统资源，降低系统对外界响应效率，而线程与进程本身也更容易进入假死状态。
于是便有了“线程池”或“连接池”。“线程池”旨在减少创建和销毁线程的频率，其维持一定合理数量的线程，并让空闲的线程重新承担新的执行任务。“连接池”维持连接的缓存池，尽量重用已有的连接、减少创建和关闭连接的频率。
但是，“线程池”和“连接池”技术也只是在一定程度上缓解了频繁调用 IO 接口带来的资源占用。而且，所谓“池”始终有其上限，当请求大大超过上限时，“池”构成的系统对外界的响应并不比没有池的时候效果好多少。所以使用“池”必须考虑其面临的响应规模，并根据响应规模调整“池”的大小。对付可能同时出现的上千甚至上万次的客户端请求，“线程池”或“连接池”或许可以缓解部分压力，但是不能解决所有问题。

于是便有了基于事件驱动的非阻塞型服务器，比如Nginx，Node.js。Nginx采用事件驱动，使用epoll事件模型，充分使用异步逻辑，削减了上下文调度开销，并发服务能力更强。Node.js 的异步机制是基于事件的，所有的磁盘 I/O、网络通信、数据库查询都以非阻塞的方式请求，返回的结果由事件循环来处理。Node.js 在执行的过程中会维护一个事件队列，程序在执行时进入事件循环等待下一个事件到来，每个异步式 I/O 请求完成后会被推送到事件队列，等待程序进程进行处理。

参考链接：
libev – a high performance full-featured event loop written in C
Working with events
使用 libevent 和 libev 提高网络应用性能
 为什么事件驱动服务器这么火
 Asynchronous PHP and Real-time Messaging
react.php 中的异步实现

PHP ZooKeeper分布式应用开发

Wed, 24 Jun 2015 09:58:29 +0800

ZooKeeper是一个中心化服务，用于分布式应用下的配置同步和协调，提供统一配置服务，统一命名服务，分布式同步，集群管理等。Zookeeper 从设计模式角度来看，是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper 就将负责通知已经在 Zookeeper 上注册的那些观察者做出相应的反应。ZooKeeper的应用场景包括：统一命名服务；配置管理；集群管理；队列管理等。

ZooKeeper作为一个Java应用程序，有大神开发了PHP的扩展：php-zookeeper。利用ZooKeeper，我们可以让分布式的PHP应用程序协调产生leader，为woker分配任务，当leader崩溃时，自动选举产生leader；也可以作分布式的锁和队列。

ZooKeeper本身是一个集群，至少需要表示3台，只要超过半数节点正常就可以工作，避免单点故障。首先需要安装JDK环境

yum search java | grep 'java-'
sudo yum install java-1.8.0-openjdk-devel

然后安装ZooKeeper，从官网下载

tar zxfv zookeeper-3.4.6.tar.gz
cd zookeeper-3.4.6/src/c
./configure --prefix=/usr/
make
sudo make install

#创建libzookeeper.conf，内容为/usr/lib，以便编译扩展使用
sudo vim /etc/ld.so.conf.d/libzookeeper.conf
#使配置生效
sudo ldconfig

然后安装PHP的扩展

cd
git clone https://github.com/andreiz/php-zookeeper.git
cd php-zookeeper
phpize
./configure
make
sudo make install

更改php.ini配置，增加以下内容

[zookeeper]
extension = zookeeper.so

查看是否加载成功

php -m | grep zookeeper

更改ZooKeeper配置，可以改变里面的DataDir熟悉，默认在/tmp下面

cp conf/zoo_sample.cfg conf/zoo.cfg
vim conf/zoo.cfg

然后终端A里面运行ZooKeeper，通过shell进行交互

cd zookeeper-3.4.6/bin
./zkServer.sh start
./zkCli.sh -server 127.0.0.1:2181
create /test hello
;Created /test
ls /
;[test, zookeeper]

这时便已成功连到了ZooKeeper，并创建了一个名为“/test”的znode。ZooKeeper以树形结构保存数据。这很类似于文件系统，但“文件夹”又和文件很像。znode是ZooKeeper保存的实体。

新建一个PHP脚本来测试一下

<?php
 
class ZookeeperDemo extends Zookeeper {
 
 public function watcher( $i, $type, $key ) {
 echo "Insider Watcher\n";
 
 // Watcher gets consumed so we need to set a new one
 $this->get( '/test', array($this, 'watcher' ) );
 }
 
}
 
$zoo = new ZookeeperDemo('127.0.0.1:2181');
$zoo->get( '/test', array($zoo, 'watcher' ) );
 
while( true ) {
 echo '.';
 sleep(2);
}

在新的终端B里面运行这个脚本

$ php zookeeperdemo1.php

返回刚才的那个终端A里面，改变节点“/test”存储的数据

set /test world

这时候在终端B里面变化打印“Insider Watcher”。注意：这里注册的回到函数仅支持对象的方法，不支持普通的函数。

前面说过，ZooKeeper是一个基于观察者模式设计的分布式服务管理框架。Zookeeper提供了绑定在znode上的监听器，一旦监听到znode数据发生变化，便会通知所有注册的客户端。所以也可以应用于发布订阅模式。

这篇文章还举例，如何让多个PHP脚本自动选举leader，分配工作。

<?php
 
class Worker extends Zookeeper {
 
 const CONTAINER = '/cluster';
 
 protected $acl = array(
 array(
 'perms' => Zookeeper::PERM_ALL,
 'scheme' => 'world',
 'id' => 'anyone' ) );
 
 private $isLeader = false;
 
 private $znode;
 
 public function __construct( $host = '', $watcher_cb = null, $recv_timeout = 10000 ) {
 parent::__construct( $host, $watcher_cb, $recv_timeout );
 }
 
 public function register() {
 if( ! $this->exists( self::CONTAINER ) ) {
 $this->create( self::CONTAINER, null, $this->acl );
 }
 
 //Zookeeper::EPHEMERAL - auto remove if client session goes away
 //Zookeeper::EPHEMERAL - auto increasing sequence number
 $this->znode = $this->create( self::CONTAINER . '/w-',
 null,
 $this->acl,
 Zookeeper::EPHEMERAL | Zookeeper::SEQUENCE );
 
 $this->znode = str_replace( self::CONTAINER .'/', '', $this->znode );
 
 printf( "I'm registred as: %s\n", $this->znode );
 
 $watching = $this->watchPrevious();
 
 if( $watching == $this->znode ) {
 printf( "Nobody here, I'm the leader\n" );
 $this->setLeader( true );
 }
 else {
 printf( "I'm watching %s\n", $watching );
 }
 }
 
 public function watchPrevious() {
 $workers = $this->getChildren( self::CONTAINER );
 sort( $workers );
 $size = sizeof( $workers );
 for( $i = 0 ; $i < $size ; $i++ ) {
 if( $this->znode == $workers[ $i ] ) {
 if( $i > 0 ) {
 //for node path change event
 $this->get( self::CONTAINER . '/' . $workers[ $i - 1 ], array( $this, 'watchNode' ) );
 //for node path exist event
 $this->exists( self::CONTAINER . '/' . $workers[ $i - 1 ], array( $this, 'watchNode' ) );
 return $workers[ $i - 1 ];
 }
 
 return $workers[ $i ];
 }
 }
 
 throw new Exception( sprintf( "Something went very wrong! I can't find myself: %s/%s",
 self::CONTAINER,
 $this->znode ) );
 }
 
 public function watchNode( $i, $type, $name ) {
 $watching = $this->watchPrevious();
 if( $watching == $this->znode ) {
 printf( "I'm the new leader!\n" );
 $this->setLeader( true );
 }
 else {
 printf( "Now I'm watching %s\n", $watching );
 }
 }
 
 public function isLeader() {
 return $this->isLeader;
 }
 
 public function setLeader($flag) {
 $this->isLeader = $flag;
 }
 
 public function run() {
 $this->register();
 
 while( true ) {
 if( $this->isLeader() ) {
 $this->doLeaderJob();
 }
 else {
 $this->doWorkerJob();
 }
 
 sleep( 2 );
 }
 }
 
 public function doLeaderJob() {
 echo "Leading\n";
 }
 
 public function doWorkerJob() {
 echo "Working\n";
 }
 
}
//host can be multiple, e.g '127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183' 
$worker = new Worker( '127.0.0.1:2181' );
$worker->run();

打开多个终端运行这个脚本。使用Ctrl+c或其他方法退出第一个脚本。刚开始不会有任何变化，worker可以继续工作。后来，ZooKeeper会发现超时，并选举出新的leader。

除此之外，利用这个扩展还可以实现一下其他的应用场景，比如排他锁和共享锁：php-zookeeper-recipes。

参考链接：
Distributed application in PHP with Apache Zookeeper
分布式服务框架 Zookeeper — 管理分布式环境中的数据
 使用Apache Zookeeper分布式部署PHP应用程序
 分布式服务框架：Zookeeper

PHP 进程间通信

Tue, 23 Jun 2015 10:54:59 +0800

上一篇介绍了PHP的多进程开发，进程间通过信号进行交互。这里介绍一下PHP的进程间通信（IPC）方法，包括基于System V IPC通信，如信号量、进程间消息、共享内存和基于socket的IPC通信。

信号量主要作为不同进程以及同一进程不同线程之间的同步手段。信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待和发送信息操作。如果信号量是一个任意的整数，通常被称为计数信号量，或一般信号量；如果信号量只有二进制的0或1，称为二进制信号量。在linux系中，二进制信号量又称Mutex，互斥锁。以下例子采用信号量来协调进程对资源的访问

<?php
$key = ftok ( __FILE__, 's' );
// 同时最多只能有一个进程进入临界区
$sem_id = sem_get ( $key, 1 );
echo "This is a room，can only stay one people!\n\r";
// 派生子进程
$pid = pcntl_fork ();
if ($pid == - 1) {
	exit ( 'fork failed!' );
} else if ($pid > 0) {
	$name = 'parent';
} else {
	$name = 'child';
}
echo "{$name} want to enter the room \n";
sem_acquire ( $sem_id );
// 原子操作开始
echo "{$name} in the room , other people can't enter!\n";
sleep ( 3 );
echo "{$name} leave the room\n";
// 原子操作结束
sem_release ( $sem_id );
if ($pid > 0) {
	pcntl_waitpid ( $pid, $status );
	sem_remove ( $sem_id ); // 移除信号量
}

sem_get和sem_remove分别为创建和销毁信号量。当前进程（父进程）通过sem_acquire获取到信号量后其他进程（子进程）将会一直阻塞直到获取到信号量；在sem_acquire和sem_release之间操作都将是原子性的；当前进程通过sem_release释放所请求的信号量，其他进程便使用，从而实现对资源的有序访问。sem_acquire是阻塞操作，即之后的程序都需要等待获取到信号量后才能继续执行。使用多个信号量控制，需要注意是否会造成死锁。

消息队列提供了一种从一个进程向另一个进程异步发送一个数据块的方法，消息的发送者和接收者不需要同时与消息队列互交。消息会保存在队列中，直到接收者取回它。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。以下是PHP子进程使用消息队列与父进程进行通信

// 生成key
$message_queue_key = ftok ( __FILE__, 'a' );
// 根据生成的key新建队列，也可自定，如123456
$message_queue = msg_get_queue ( $message_queue_key, 0666 );

$pids = array ();
for($i = 0; $i < 5; $i ++) {
	// 创建子进程
	$pids [$i] = pcntl_fork ();
	
	if ($pids [$i]) {
		echo "No.$i child process was created, the pid is $pids[$i]\r\n";
		pcntl_wait ( $status ); // 非阻塞的线程等待,防止僵尸进程的出现
	} elseif ($pids [$i] == 0) {
		$pid = posix_getpid ();
		echo "process.$pid is writing now\r\n";
		// 写队列
		msg_send ( $message_queue, 1, "this is process.$pid's data\r\n" );
		posix_kill ( $pid, SIGTERM );
	}
}

do {
	// 读队列
	msg_receive ( $message_queue, 0, $message_type, 1024, $message, true, MSG_IPC_NOWAIT );
	echo $message;
	// 获取队列内消息数
	$a = msg_stat_queue ( $message_queue );
	if ($a ['msg_qnum'] == 0) {
		break;
	}
} while ( true );

消息队列存在消息大小及队列长度的限制，一旦超过将写不进去。

共享内存使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。一个进程在内存创建了一个共享区域，其他进程也可以对这块内存区域进行访问

<?php
//Check the command line arguments
if(sizeof($argv) < 2) {
 echo "Usage: php shared_memory.php <send|get|delete> <integer identifier> <value>\n";
 exit;
}
 
//Define shared memory segment properties.
$key = "987654";
$permissions = 0666;
$size = 1024;
 
//Create or open the shared memory segment.
$segment = shm_attach($key, $size, $permissions);
 
//Handle operations for the segment.
switch($argv[1]) {
 case "send":
 shm_put_var($segment, $argv[2], $argv[3]);
 echo "Message sent to shared memory segment.\n";
 break;
 case "get":
 $data = shm_get_var($segment, $argv[2]);
 echo "Received data: {$data}\n";
 break;
 case "delete":
 shm_remove($segment);
 echo "Shared memory segment released.\n";
 break;
}

共享内存并未提供同步机制，往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。PHP还有另外一个共享内存扩展：shmop。注意，共享内存存在内存限制。

Sockets IPC提供了进程间双向的点对点通信。通过socket_create_pair创建一对socket，作为上行和下行，父进程和子进程分别使用其中一个进行读写通信

<?php
$sockets = array();
$strone = 'Message From Parent.';
$strtwo = 'Message From Child.';

if (socket_create_pair(AF_UNIX, SOCK_STREAM, 0, $sockets) === false) {
 echo "socket_create_pair() failed. Reason: ".socket_strerror(socket_last_error());
}
$pid = pcntl_fork();
if ($pid == -1) {
 echo 'Could not fork Process.';
} elseif ($pid) {
 /*parent*/
 socket_close($sockets[0]);
 if (socket_write($sockets[1], $strone, strlen($strone)) === false) {
 echo "socket_write() failed. Reason: ".socket_strerror(socket_last_error($sockets[1]));
 }
 if (socket_read($sockets[1], strlen($strtwo), PHP_BINARY_READ) == $strtwo) {
 echo "Recieved $strtwo\n";
 }
 socket_close($sockets[1]);
} else {
 /*child*/
 socket_close($sockets[1]);
 if (socket_write($sockets[0], $strtwo, strlen($strtwo)) === false) {
 echo "socket_write() failed. Reason: ".socket_strerror(socket_last_error($sockets[0]));
 }
 if (socket_read($sockets[0], strlen($strone), PHP_BINARY_READ) == $strone) {
 echo "Recieved $strone\n";
 }
 socket_close($sockets[0]);
}

以下例子是github上一个利用PHP Sockets IP开发的多进程任务处理

<?php
namespace Lifo\IPC;

declare(ticks = 1);

interface ProcessInterface
{
	public function run($parent);
}

class ProcessPoolException extends \Exception
{
	
}

class ProcessPool
{
 /** @var Integer Maximum workers allowed at once */
 protected $max;
 /** @var boolean If true workers will fork. Otherwise they will run synchronously */
 protected $fork;
 /** @var Integer Total results collected */
 protected $count;
 /** @var array Pending processes that have not been started yet */
 protected $pending;
 /** @var array Processes that have been started */
 protected $workers;
 /** @var array Results that have been collected */
 protected $results;
 /** @var \Closure Function to call every time a child is forked */
 protected $createCallback;
 /** @var array children PID's that died prematurely */
 private $caught;
 /** @var boolean Is the signal handler initialized? */
 private $initialized;
 private static $instance = array();
 public function __construct($max = 1, $fork = true)
 {
 //$pid = getmypid();
 //if (isset(self::$instance[$pid])) {
 // $caller = debug_backtrace();
 // throw new ProcessPoolException("Cannot instantiate more than 1 ProcessPool in the same process in {$caller[0]['file']} line {$caller[0]['line']}");
 //}
 //self::$instance[$pid] = $this;
 $this->count = 0;
 $this->max = $max;
 $this->fork = $fork;
 $this->results = array();
 $this->workers = array();
 $this->pending = array();
 $this->caught = array();
 $this->initialized = false;
 }
 public function __destruct()
 {
 // make sure signal handler is removed
 $this->uninit();
 //unset(self::$instance[getmygid()]);
 }
 /**
 * Initialize the signal handler.
 *
 * Note: This will replace any current handler for SIGCHLD.
 *
 * @param boolean $force Force initialization even if already initialized
 */
 private function init($force = false)
 {
 if ($this->initialized and !$force) {
 return;
 }
 $this->initialized = true;
 pcntl_signal(SIGCHLD, array($this, 'signalHandler'));
 }
 private function uninit()
 {
 if (!$this->initialized) {
 return;
 }
 $this->initialized = false;
 pcntl_signal(SIGCHLD, SIG_DFL);
 }
 public function signalHandler($signo)
 {
 switch ($signo) {
 case SIGCHLD:
 $this->reaper();
 break;
 }
 }
 /**
 * Reap any dead children
 */
 public function reaper($pid = null, $status = null)
 {
 if ($pid === null) {
 $pid = pcntl_waitpid(-1, $status, WNOHANG);
 }
 while ($pid > 0) {
 if (isset($this->workers[$pid])) {
 // @todo does the socket really need to be closed?
 //@socket_close($this->workers[$pid]['socket']);
 unset($this->workers[$pid]);
 } else {
 // the child died before the parent could initialize the $worker
 // queue. So we track it temporarily so we can handle it in
 // self::create().
 $this->caught[$pid] = $status;
 }
 $pid = pcntl_waitpid(-1, $status, WNOHANG);
 }
 }
 /**
 * Wait for any child to be ready
 *
 * @param integer $timeout Timeout to wait (fractional seconds)
 * @return array|null Returns array of sockets ready to be READ or null
 */
 public function wait($timeout = null)
 {
 $x = null; // trash var needed for socket_select
 $startTime = microtime(true);
 while (true) {
 $this->apply(); // maintain worker queue
 // check each child socket pair for a new result
 $read = array_map(function($w){ return $w['socket']; }, $this->workers);
 // it's possible for no workers/sockets to be present due to REAPING
 if (!empty($read)) {
 $ok = @socket_select($read, $x, $x, $timeout);
 if ($ok !== false and $ok > 0) {
 return $read;
 }
 }
 // timed out?
 if ($timeout and microtime(true) - $startTime > $timeout) {
 return null;
 }
 // no sense in waiting if we have no workers and no more pending
 if (empty($this->workers) and empty($this->pending)) {
 return null;
 }
 }
 }
 /**
 * Return the next available result.
 *
 * Blocks unless a $timeout is specified.
 *
 * @param integer $timeout Timeout in fractional seconds if no results are available.
 * @return mixed Returns next child response or null on timeout
 * @throws ProcessPoolException On timeout if $nullOnTimeout is false
 */
 public function get($timeout = null, $nullOnTimeout = false)
 {
 $startTime = microtime(true);
 while ($this->getPending()) {
 // return the next result
 if ($this->hasResult()) {
 return $this->getResult();
 }
 // wait for the next result
 $ready = $this->wait($timeout);
 if (is_array($ready)) {
 foreach ($ready as $socket) {
 $res = self::socket_fetch($socket);
 if ($res !== null) {
 $this->results[] = $res;
 $this->count++;
 }
 }
 if ($this->hasResult()) {
 return $this->getResult();
 }
 }
 // timed out?
 if ($timeout and microtime(true) - $startTime > $timeout) {
 if ($nullOnTimeout) {
 return null;
 }
 throw new ProcessPoolException("Timeout");
 }
 }
 }
 /**
 * Return results from all workers.
 *
 * Does not return until all pending workers are complete or the $timeout
 * is reached.
 *
 * @param integer $timeout Timeout in fractional seconds if no results are available.
 * @return array Returns an array of results
 * @throws ProcessPoolException On timeout if $nullOnTimeout is false
 */
 public function getAll($timeout = null, $nullOnTimeout = false)
 {
 $results = array();
 $startTime = microtime(true);
 while ($this->getPending()) {
 try {
 $res = $this->get($timeout);
 if ($res !== null) {
 $results[] = $res;
 }
 } catch (ProcessPoolException $e) {
 // timed out
 }
 // timed out?
 if ($timeout and microtime(true) - $startTime > $timeout) {
 if ($nullOnTimeout) {
 return null;
 }
 throw new ProcessPoolException("Timeout");
 }
 }
 return $results;
 }
 public function hasResult()
 {
 return !empty($this->results);
 }
 /**
 * Return the next available result or null if none are available.
 *
 * This does not wait or manage the worker queue.
 */
 public function getResult()
 {
 if (empty($this->results)) {
 return null;
 }
 return array_shift($this->results);
 }
 /**
 * Apply a worker to the working or pending queue
 *
 * @param Callable $func Callback function to fork into.
 * @return ProcessPool
 */
 public function apply($func = null)
 {
 // add new function to pending queue
 if ($func !== null) {
 if ($func instanceof \Closure or $func instanceof ProcessInterface or is_callable($func)) {
 $this->pending[] = func_get_args();
 } else {
 throw new \UnexpectedValueException("Parameter 1 in ProcessPool#apply must be a Closure or callable");
 }
 }
 // start a new worker if our current worker queue is low
 if (!empty($this->pending) and count($this->workers) < $this->max) {
 call_user_func_array(array($this, 'create'), array_shift($this->pending));
 }
 return $this;
 }
 /**
 * Create a new worker.
 *
 * If forking is disabled this will BLOCK.
 *
 * @param Closure $func Callback function.
 * @param mixed Any extra parameters are passed to the callback function.
 * @throws \RuntimeException if the child can not be forked.
 */
 protected function create($func /*, ...*/)
 {
 // create a socket pair before forking so our child process can write to the PARENT.
 $sockets = array();
 $domain = strtoupper(substr(PHP_OS, 0, 3)) == 'WIN' ? AF_INET : AF_UNIX;
 if (socket_create_pair($domain, SOCK_STREAM, 0, $sockets) === false) {
 throw new \RuntimeException("socket_create_pair failed: " . socket_strerror(socket_last_error()));
 }
 list($child, $parent) = $sockets; // just to make the code below more readable
 unset($sockets);
 $args = array_merge(array($parent), array_slice(func_get_args(), 1));
 $this->init(); // make sure signal handler is installed
 if ($this->fork) {
 $pid = pcntl_fork();
 if ($pid == -1) {
 throw new \RuntimeException("Could not fork");
 }
 if ($pid > 0) {
 // PARENT PROCESS; Just track the child and return
 socket_close($parent);
 $this->workers[$pid] = array(
 'pid' => $pid,
 'socket' => $child,
 );
 // don't pass $parent to callback
 $this->doOnCreate(array_slice($args, 1));
 // If a SIGCHLD was already caught at this point we need to
 // manually handle it to avoid a defunct process.
 if (isset($this->caught[$pid])) {
 $this->reaper($pid, $this->caught[$pid]);
 unset($this->caught[$pid]);
 }
 } else {
 // CHILD PROCESS; execute the callback function and wait for response
 socket_close($child);
 try {
 if ($func instanceof ProcessInterface) {
 $result = call_user_func_array(array($func, 'run'), $args);
 } else {
 $result = call_user_func_array($func, $args);
 }
 if ($result !== null) {
 self::socket_send($parent, $result);
 }
 } catch (\Exception $e) {
 // this is kind of useless in a forking context but at
 // least the developer can see the exception if it occurs.
 throw $e;
 }
 exit(0);
 }
 } else {
 // forking is disabled so we simply run the child worker and wait
 // synchronously for response.
 try {
 if ($func instanceof ProcessInterface) {
 $result = call_user_func_array(array($func, 'run'), $args);
 } else {
 $result = call_user_func_array($func, $args);
 }
 if ($result !== null) {
 //$this->results[] = $result;
 self::socket_send($parent, $result);
 }
 // read anything pending from the worker if they chose to write
 // to the socket instead of just returning a value.
 $x = null;
 do {
 $read = array($child);
 $ok = socket_select($read, $x, $x, 0);
 if ($ok !== false and $ok > 0) {
 $res = self::socket_fetch($read[0]);
 if ($res !== null) {
 $this->results[] = $res;
 }
 }
 } while ($ok);
 } catch (\Exception $e) {
 // nop; we didn't fork so let the caller handle it
 throw $e;
 }
 }
 }
 /**
 * Clear all pending workers from the queue.
 */
 public function clear()
 {
 $this->pending = array();
 return $this;
 }
 /**
 * Send a SIGTERM (or other) signal to the PID given
 */
 public function kill($pid, $signo = SIGTERM)
 {
 posix_kill($pid, $signo);
 return $this;
 }
 /**
 * Send a SIGTERM (or other) signal to all current workers
 */
 public function killAll($signo = SIGTERM)
 {
 foreach ($this->workers as $w) {
 $this->kill($w['pid'], $signo);
 }
 return $this;
 }
 /**
 * Set a callback when a new forked process is created. This will allow the
 * parent to perform some sort of cleanup after every child is created.
 *
 * This is useful to reinitialize certain resources like DB connections
 * since children will inherit the parent resources.
 *
 * @param \Closure $callback Function to callback after every forked child.
 */
 public function setOnCreate(\Closure $callback = null)
 {
 $this->createCallback = $callback;
 }
 protected function doOnCreate($args = array())
 {
 if ($this->createCallback) {
 call_user_func_array($this->createCallback, $args);
 }
 }
 /**
 * Return the total jobs that have NOT completed yet.
 */
 public function getPending($pendingOnly = false)
 {
 if ($pendingOnly) {
 return count($this->pending);
 }
 return count($this->pending) + count($this->workers) + count($this->results);
 }
 public function getWorkers()
 {
 return count($this->workers);
 }
 public function getActive()
 {
 return count($this->pending) + count($this->workers);
 }
 public function getCompleted()
 {
 return $this->count;
 }
 public function setForking($fork)
 {
 $this->fork = $fork;
 return $this;
 }
 public function setMax($max)
 {
 if (!is_numeric($max) or $max < 1) {
 throw new \InvalidArgumentException("Max value must be > 0");
 }
 $this->max = $max;
 return $this;
 }
 public function getMax()
 {
 return $this->max;
 }
 /**
 * Write the data to the socket in a predetermined format
 */
 public static function socket_send($socket, $data)
 {
 $serialized = serialize($data);
 $hdr = pack('N', strlen($serialized)); // 4 byte length
 $buffer = $hdr . $serialized;
 $total = strlen($buffer);
 while (true) {
 $sent = socket_write($socket, $buffer);
 if ($sent === false) {
 // @todo handle error?
 //$error = socket_strerror(socket_last_error());
 break;
 }
 if ($sent >= $total) {
 break;
 }
 $total -= $sent;
 $buffer = substr($buffer, $sent);
 }
 }
 /**
 * Read a data packet from the socket in a predetermined format.
 *
 * Blocking.
 *
 */
 public static function socket_fetch($socket)
 {
 // read 4 byte length first
 $hdr = '';
 do {
 $read = socket_read($socket, 4 - strlen($hdr));
 if ($read === false or $read === '') {
 return null;
 }
 $hdr .= $read;
 } while (strlen($hdr) < 4);
 list($len) = array_values(unpack("N", $hdr));
 // read the full buffer
 $buffer = '';
 do {
 $read = socket_read($socket, $len - strlen($buffer));
 if ($read === false or $read == '') {
 return null;
 }
 $buffer .= $read;
 } while (strlen($buffer) < $len);
 $data = unserialize($buffer);
 return $data;
 }
}


$pool = new ProcessPool(16);
for ($i=0; $i<100; $i++) {
	$pool->apply(function($parent) use ($i) {
		echo "$i running...\n";
		mt_srand(); // must re-seed for each child
		$rand = mt_rand(1000000, 2000000);
		usleep($rand);
		return $i . ' : slept for ' . ($rand / 1000000) . ' seconds';
 });
}
while ($pool->getPending()) {
	try {
		$result = $pool->get(1); // timeout in 1 second
		echo "GOT: ", $result, "\n";
	} catch (ProcessPoolException $e) {
			// timeout
	}
}

当前进程（父进程）添加任务时交由其他进程（子进程）处理，不阻塞当前进程；其他进程运行结束后，通过socket返回结果给父进程。

当然进程间通信也可以通过文件（FIFO）或者类似的中介角色如异步消息队列，Mysql，Redis等等进行交互。

参考链接：
Semaphore, Shared Memory and IPC
深刻理解Linux进程间通信（IPC）
PHP IPC with Daemon Service using Message Queues, Shared Memory and Semaphores
关于PHP你可能不知道的－PHP的事件驱动化设计
 Store datasets directly in shared memory with PHP
PHP Dark Arts: Shared Memory Segments (IPC)
Something Like Threading – PHP Process Forking and Interprocess Communication
Mimicking Threading in PHP
基于System V Message queue的PHP消息队列封装
 PHP进程间通信System V消息队列
 PHP进程间通信System V信号量
 we Do web sockets on PHP from null. A part 2. IPC
proc_open

PHP 进程控制PCNTL

Thu, 18 Jun 2015 20:01:11 +0800

PHP的进程控制PCNTL支持实现了Unix方式的进程创建, 程序执行，信号处理以及进程的中断。 PCNTL只支持linux平台下cli模式，不支持Windows平台，也不能被应用在Web服务器环境（cgi等），当其被用于Web服务环境时可能会带来意外的结果。通常，PCNTL会结合另外一个扩展来使用POSIX来开发（也不支持Windows平台）。

pcntl_fork可以创建一个子进程，父进程和子进程都从fork的位置开始向下继续执行。创建成功时，父进程得到的返回值是子进程号而子进程得到的返回值是0；创建失败时，父进程得到返回值是-1，不会创建子进程，并触发一个PHP错误。

<?php

$pid = pcntl_fork();
//父进程和子进程都会执行下面代码
if ($pid == -1) {
 //错误处理：创建子进程失败时返回-1.
 die('could not fork');
} else if ($pid) {
 //父进程会得到子进程号，所以这里是父进程执行的逻辑
 pcntl_wait($status); //等待子进程中断，防止子进程成为僵尸进程。
} else {
 //子进程得到的$pid为0, 所以这里是子进程执行的逻辑。
}

在对应的父进程结束执行后，子进程就会变成孤儿进程，但之后会立即由init进程（进程ID为1）“收养”为其子进程。

某一子进程终止执行后，若其父进程未提前调用wait，则内核会持续保留子进程的退出状态等信息，以使父进程可以wait获取之[2] 。而因为在这种情况下，子进程虽已终止，但仍在消耗系统资源，所以其亦称僵尸进程。wait常于SIGCHLD信号的处理函数中调用。

为避免产生僵尸进程，一般采取的方式是：将父进程中对SIGCHLD信号的处理函数设为SIG_IGN（忽略信号）；fork两次并杀死一级子进程，令二级子进程成为孤儿进程而被init所“收养”、清理。

采用二次创建子进程的方式

<?php
	$pid = pcntl_fork();
	if($pid) {
		//创建成功，在父进程中执行
		echo "run in parent process";//pcntl_wait($status);
	} else if($pid == -1) {
		//创建失败，在父进程中处理
		echo "Couldn't create child process.";
	} else {
		//创建成功，在子进程中执行
		//再次创建子进程，即孙进程
		$pid = pcntl_fork();
		if($pid == 0) {
			//在孙进程中执行
			if(-1 == posix_setsid())
	 {
	 // 出错退出
	 exit("Setsid fail");
	 }
			echo "run in grandchild process";
		} else if($pid == -1) {
			echo "Couldn’t create child process.";
		} else {
			//在子进程中处理
			echo "run in child process.";//posix_kill(posix_getpid(), SIGUSR1);
			exit;
		}
	}

通常还会把子进程的pid收集以来，以便监控、回收，如workerman。二次创建子进程通常应用在PHP多进程，守护进程上，比如

<?php
defined('DEAMON_LOCK_FILE') ||
define('DEAMON_LOCK_FILE', 'run/deamon.pid');

if($_SERVER['argc'] >= 2 && $_SERVER['argv'][1] == 'kill')
{
	$fh = fopen(realpath(__DIR__) . '/' . DEAMON_LOCK_FILE, 'r');
	$pid = fread($fh, 8);

	if( $pid )
		posix_kill($pid, SIGTERM);

	exit;
}

global $DEAMON_LOCK_HANDLER;

function daemonize($signalHandler = false ) {
	global $DEAMON_LOCK_HANDLER;

	if( ! deamon_file_lock() ) {
		printf("Deamon is already running...\n");
		exit();
	}

	umask(0);

	$pid = pcntl_fork();

	if( $pid < 0 ) {
		printf("Can't fork\n");
		exit;
	}
	else if( $pid ) {
		exit;
	}

	$sid = posix_setsid();

	if( $sid < 0 ) {
		printf("Can't set session leader\n");
		exit;
	}

	deamon_bind_signals($signalHandler);

	$pid = pcntl_fork();

	if( $pid < 0 || $pid ) {
		exit;
	}

	ftruncate($DEAMON_LOCK_HANDLER, 0);
	fwrite($DEAMON_LOCK_HANDLER, posix_getpid());

	chdir('/');

	fclose( STDIN );
	fclose( STDOUT );
	fclose( STDERR );
}

function deamon_bind_signals($signalHandler = false) {
	$signalHandler = !$signalHandler ? "deamon_signal_handler" : $signalHandler;

	pcntl_signal(SIGTERM, $signalHandler);
	pcntl_signal(SIGHUP, $signalHandler);
	pcntl_signal(SIGUSR1, $signalHandler);
	pcntl_signal(SIGINT, $signalHandler);
}

function deamon_file_lock() {
	global $DEAMON_LOCK_HANDLER;
	$DEAMON_LOCK_HANDLER = fopen(realpath(__DIR__) . '/' . DEAMON_LOCK_FILE, 'c');

	if( ! $DEAMON_LOCK_HANDLER ) {
		printf("Can't open lock file\n");
		die();
	}
	if( !flock( $DEAMON_LOCK_HANDLER, LOCK_EX | LOCK_NB ) ) {
		return false;
	}
	return true;
}

function deamon_signal_handler($signo) {
	switch( $signo ) {
		case SIGTERM:
		case SIGHUP:
		case SIGUSR1:
			break;
	}
}

function sighandler($sig) {
 //do something
	if( $sig == SIGTERM ) {
		global $DEAMON_LOCK_HANDLER;
		fclose( $DEAMON_LOCK_HANDLER );
		exit;
	}
}
daemonize("sighandler");

while( 1 ) {
	pcntl_signal_dispatch();
	// do something here
	sleep( 1 );
}

可以通过ps -ef | grep php查看过程中的php进程产生情况，CentOS下安装PHP5.4的Posix扩展为：sudo yum instal php54w-process。

pcntl_signal可以注册信号处理函数，捕获信号后交给对应回调函数处理，实现信号通信，例如当某一子进程结束、中断或恢复执行时，内核会发送SIGCHLD信号予其父进程

<?php
declare(ticks = 1);

pcntl_signal(SIGCHLD, "signal_handler");

function signal_handler($signal) {
	switch($signal) {
		case SIGCHLD:
			while (pcntl_waitpid(0, $status) != -1) {
				$status = pcntl_wexitstatus($status);
				echo "Child $status completed\n";
			}

			exit;
	}
}

for ($i = 1; $i <= 5; ++$i) {
	$pid = pcntl_fork();

	if (!$pid) {
		sleep(1);
		print "In child $i\n";
		exit($i);
	}
}

while(1) {
	// parent does processing here...
}

pcntl_alarm创建一个计时器，在指定的秒数后向进程发送一个SIGALRM信号，结合pcntl_signal和pcntl_alarm可以做一个秒级的定时器（注意：pcntl_alarm是一次性消耗，需要再次设置）

declare(ticks = 1);

function signal_handler($signal) {
	//do your work here
	print "Caught SIGALRM\n";
	pcntl_alarm(3);
}

pcntl_signal(SIGALRM, "signal_handler", true);
pcntl_alarm(3);

while(1) {
}

利用PHP的进程控制便可以实现守护进程监控，如socke端口监听；多进程处理，如socke请求事件处理、任务并行、异步处理，提升PHP程序性能。

参考链接：
PHP 进程控制
 Getting into multiprocessing
Timing your signals
PHP Deamon
PHP中利用pcntl进行多进程并发控制
 PHP高级编程之守护进程
 PHP多进程编程一，PHP多进程编程二。
PHP的ticks机制
 PHP如何将进程作为守护进程
 Daemonising a PHP cli script on a posix system
异步毫秒定时器
 The declare() function and ticks
子进程

PHP 扩展开发之C

Thu, 11 Jun 2015 23:06:33 +0800

前面介绍了使用Zephir来开发PHP扩展，将PHP代码转为扩展，以提升性能，保护代码。目前更多的扩展都是采用C/C++开发的，最近在项目开发中，需要在这些已有的PHP扩展上开发，也只能用C/C++来开发了。

首先去PHP官网下载对应版本的PHP源码，解压并进入对应的目录。
创建扩展courages：

[vagrant@vagrant-centos64 ext]$ ./ext_skel
./ext_skel --extname=module [--proto=file] [--stubs=file] [--xml[=file]]
 [--skel=dir] [--full-xml] [--no-help]

 --extname=module module is the name of your extension
 --proto=file file contains prototypes of functions to create
 --stubs=file generate only function stubs in file
 --xml generate xml documentation to be added to phpdoc-cvs
 --skel=dir path to the skeleton directory
 --full-xml generate xml documentation for a self-contained extension
 (not yet implemented)
 --no-help don't try to be nice and create comments in the code
 and helper functions to test if the module compiled
[vagrant@vagrant-centos64 ext]$ ./ext_skel --extname=courages
Creating directory courages
Creating basic files: config.m4 config.w32 .svnignore courages.c php_courages.h CREDITS EXPERIMENTAL tests/001.phpt courages.php [done].

To use your new extension, you will have to execute the following steps:

1. $ cd ..
2. $ vi ext/courages/config.m4
3. $ ./buildconf
4. $ ./configure --[with|enable]-courages
5. $ make
6. $ ./sapi/cli/php -f ext/courages/courages.php
7. $ vi ext/courages/courages.c
8. $ make

Repeat steps 3-6 until you are satisfied with ext/courages/config.m4 and
step 6 confirms that your module is compiled into PHP. Then, start writing
code and repeat the last two steps as often as necessary.

这里的步骤说的很清楚，但这一次，步骤3被phpize代替了。

按部就班，编辑config.m4，PHP_ARG_WITH是采用动态库方式加载（PHP_ARG_ENABLE则是编译内核中，configure是–enable-extension使用），将

dnl PHP_ARG_WITH(courages, whether to enable courages support,
dnl Make sure that the comment is aligned:
dnl [ --with-courages Include courages support])

更改为

PHP_ARG_WITH(courages, for courages support,
[ --with-courages Include courages support])

然后，在php_courages.h增加函数声明

PHP_FUNCTION(confirm_courages_compiled);	/* For testing, remove later. */
PHP_FUNCTION(courages_helloworld);

接着，编辑courages.c，在function_entry中增加函数注册

const zend_function_entry courages_functions[] = {
	PHP_FE(confirm_courages_compiled,	NULL)		/* For testing, remove later. */
 	PHP_FE(courages_helloworld, NULL)
	PHP_FE_END	/* Must be the last line in courages_functions[] */
};

然后是courages_helloworld函数实现

PHP_FUNCTION(courages_helloworld)
{
 char *arg = NULL;
	int arg_len, len;
	char *strg;
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
		return;
	}
	len = spprintf(&strg, 0, "Your input string: %s/n", arg);
	php_printf(strg);
	return SUCCESS;
}

最后就是编译

phpize
./configure
sudo make
sudo make install

sudo vim /etc/php.ini

在php.ini中增加扩展courages.so

[courages]
extension = courages.so

测试一下

[vagrant@vagrant-centos64 courages]$ php -m | grep 'courages'
courages

[vagrant@vagrant-centos64 courages]$ php courages.php
Functions available in the test extension:
confirm_courages_compiled
courages_helloworld

Your input string: hellow world
Congratulations! You have successfully modified ext/courages/config.m4. Module courages is now compiled into PHP.

到这里一个扩展的开发流程就结束了。

这里分享一些小技巧。
首先是如何在PHP扩展中获取PHP全局数组$_SERVER($_POST/GET)变量中的值：

static char *get_server_var_by_name(char *str){
	// This code makes sure $_SERVER has been initialized
	if (!zend_hash_exists(&EG(symbol_table), "_SERVER", 8)) {
		zend_auto_global* auto_global;
		if (zend_hash_find(CG(auto_globals), "_SERVER", 8, (void **)&auto_global) != FAILURE) {
			auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
		}
	}

	// This fetches $_SERVER['PHP_SELF']
	zval** arr;
	char* script_name;
	if (zend_hash_find(&EG(symbol_table), "_SERVER", 8, (void**)&arr) != FAILURE) {
		HashTable* ht = Z_ARRVAL_P(*arr);
		zval** val;
		if (zend_hash_find(ht, str, strlen(str)+1, (void**)&val) != FAILURE) {
			script_name = Z_STRVAL_PP(val);
		}
	}
	return script_name;
}

然后是如何在PHP扩展调用PHP函数:

/*调用无参数函数*/
static char *get_sapi_name(){
 zval *function_name;
 zval *retval;
	char *sapi_name;

 MAKE_STD_ZVAL(function_name);
 ZVAL_STRING(function_name , "php_sapi_name", 1);


 if (call_user_function_ex(EG(function_table), NULL, function_name, &retval, 0, NULL, 0, EG(active_symbol_table) TSRMLS_CC) != SUCCESS)
 {
 zend_error(E_ERROR, "Function call failed");
 }

 if (retval != NULL && Z_TYPE_P(retval) != IS_STRING) {
 convert_to_string(retval);
 sapi_name = Z_STRVAL_P(retval);
 }
 else{
	sapi_name = "cli";
 }

 return sapi_name;
}
/*调用有参数函数*/
static int _ck_dir(char *dir TSRMLS_DC)
{
 zval *function_name;
 zval *retval;
 zval *str;
 zval **param[1];

 MAKE_STD_ZVAL(function_name);
 ZVAL_STRING(function_name , "is_dir", 1);

 MAKE_STD_ZVAL(str);
 ZVAL_STRING(str, dir, 1);
 param[0] = &str;

 if (call_user_function_ex(EG(function_table), NULL, function_name, &retval, 1, param, 0, EG(active_symbol_table) TSRMLS_CC) != SUCCESS)
 {
 zend_error(E_ERROR, "Function call failed");
 }

 if (retval != NULL && zval_is_true(retval)) {
 return SUCCESS;
 }

 return FAILURE;
}

更高级的一些技巧可以参考《PHP扩展开发及内核应用》和阅读别人的扩展开发代码。

参考链接：
php扩展实战 —— 获得ip的来源地址
 如何编写一个PHP的C扩展
 [原创]快速开发一个PHP扩展
 用C/C++扩展你的PHP
Get the name of running script from a PHP extension
Build PHP extension and use call_user_function
Programming PHP
与 UNIX 构建系统交互: config.m4
call_user_function_ex() documentation
PHP Extensions Made Eldrich: PHP Variables
Convert Zval to char*
PHP扩展编写第一步：PHP和Zend介绍
 PHP扩展开发：简单类实现
 自己写PHP扩展之创建一个类[原创]
如何在扩展里调用PHP函数呢?

PHP队列开发之Beanstalk

Mon, 08 Jun 2015 17:02:01 +0800

Beanstalk是一个基于内存的（binlog持久化到硬盘），事件驱动（libevent），简单、快速的任务队列，支持大部分编程语言，将前台的任务转为后台异步处理，为web开发提供更高弹性。它可以支持多个server（客户端支持），一个任务只会被投递到一台server，一个任务只会被一个消费者获取（Reverse）。

相比RabbitMQ，Beanstalk作为一个任务队列，设计比较简单，支持以下特性：

优先级（priority），可以对任务进行优先处理（或降级），越小的值优先级越高（0～4,294,967,295），默认按先进先出（FIFO）
延迟执行（delay），一个任务创建完成并稍后再执行（比如等待主从同步）
超时重试（TTR），一个任务没有在指定时间内完成，将会被重新投递，由其他客户端处理。客户端也可以主动进行延时（touch)或重新入队（release）
隐藏（bury），一个任务执行失败了，可以先隐藏，隐藏的任务可以被重新激活（kick）；

一个任务如果没有被删除，那么它就可以被重新获取。下面是大多数任务的生命周期:

 put with delay release with delay
 ----------------> [DELAYED] <------------.
 | |
 | (time passes) |
 | |
 put v reserve | delete
 -----------------> [READY] ---------> [RESERVED] --------> *poof*
 ^ ^ | |
 | \ release | |
 | `-------------' |
 | |
 | kick |
 | |
 | bury |
 [BURIED] <---------------'
 |
 | delete
 `--------> *poof*

CentOS下安装Beanstalkd

sudo yum install beanstalkd
#启动beanstalk
sudo service beanstalkd start
#beanstalkd -l 192.168.33.14 -p 11300

PHP下面有个C扩展beanstalk库可以使用，基于libbeanstalkclient

git clone https://github.com/bergundy/libbeanstalkclient.git
cd libbeanstalkclient
mkdir m4
#开始编译
sudo ./autogen.sh

#创建libbeanstalkclient.conf，内容为/usr/lib
sudo vim /etc/ld.so.conf.d/libbeanstalkclient.conf
#使配置生效
sudo ldconfig

git clone https://github.com/nil-zhang/php-beanstalk.git
cd php-beanstalk
phpize
./configure
sudo make
sudo make install
sudo vim /etc/php.ini

编辑php.ini增加以下内容

[beanstalk]
extension = "beanstalk.so"

查看是否加载成功

php -m
#加载成功则重启php-fpm
sudo service php-fpm restart

PHP测试代码

<?php
 $bsc = new Beanstalk();

 $bsc->addserver("192.168.33.14", 11300);
 $bsc->addserver("192.168.33.12", 11300);

 $tubes = $bsc->list_tubes();
 print_r($tubes);

 for($i = 0; $i < 10; $i++)
 {
 $key = "key".$i;
 $value = "value".$i;

 $bsc->use($key);
 $bsc->put($key, $value);
 echo "$key\t$value\n";

 $bsc->watch($key);
 $job = $bsc->reserve($key);
 print_r($job);

 if($bsc->bury($job['id'], $key))
 echo "bury ok\n";
 else
 echo "bury failed\n";

 $bsc->kick(100, $key);
 if($bsc->delete($job['id'], $key))
 echo "delete ok\n";
 else
 echo "delete failed \n";

 $bsc->ignore($key);
 echo "\n";
 }

 echo "done\n";

注意由于Beanstalk服务端实现的比较简单，协议特性需要客户端支持，不同的实现可能效果不一样，这个客户端并没有实现延时发送（delay），超时重试（TTR）。需要这些特性建议使用这个库：PHP Beanstalkd。前台生产者创建任务：

<?php
include 'lib/Beanstalk.php';
$bean = Beanstalk::init();
$bean->addServer('192.168.33.14', 11300);
$bean->addServer('192.168.33.12', 11300);
$bean->useTube('my-tube');
$bean->put('Hello World!', 1024);
$bean->put('Hello World!2', 1023);
$bean->put(json_encode(array('what','how')), 1000, 1, 1);

后台消费者处理任务

include 'lib/Beanstalk.php';
$bean = Beanstalk::init();
$bean->addServer('192.168.33.12', 11300);
$bean->addServer('192.168.33.14', 11300);
$bean->watchTube('my-tube');

while (true)
{
	try
	{
		$job = $bean->reserve($timeout = 10);

		/* process job ... */
		var_dump($job);
		//var_dump($job->getMessage());

		$job->delete();
	}
	catch (BeanstalkException $e)
	{
		switch ($e->getCode())
		{
			case BeanstalkException::TIMED_OUT:
				echo "Timed out waiting for a job. Retrying in 1 second.";
				sleep(1);
				continue;
				break;
			default:
				throw $e;
				break;
		}
	}
}

注意：客户端获取任务（reverse）是阻塞的（blocking），直到超时；同一个队列（tube）的任务按FIFO进行处理（除非指定优先级）；任务内容长度不能超过65536；作为内存队列需要注意是否会内存超出，可以快速处理到Mysql。

使用Beanstalk任务队列提升PHP异步处理能力，降低程序耦合度，使前台更专注，后台处理耗时、扩展性任务（也可以使用其他语言开发），使得web架构更具扩展性。

参考链接：
Scalable Work Queues with Beanstalk
Beanstalk Protocol
Frequently Asked Questions for beanstalkd
Getting Started with Beanstalkd
Queue your work
Asynchronous Processing in Web Applications, Part 2: Developers Need to Understand Message Queues

PHP yield应用

Mon, 25 May 2015 18:48:33 +0800

PHP 5.5开始新增了神奇的关键字yield，能够从生成器（generators）中返回数据。yield有点像普通函数中的关键字return，但是不会彻底停止函数的执行（普通函数一旦return便不执行了），可以暂停循环并返回值，每一次调用便从中断处继续迭代。生成器可以用于替代循环迭代，每一次调用返回一个生成器对象（generator）。

yield能够延迟执行，可以用于对大量数据进行迭代而不用预先在内存中生成数组。例如动态生成一个大数组：

<?php
function xrange($start, $end, $step = 1) {
 for ($i = $start; $i <= $end; $i += $step) {
 yield $i;
 }
}

foreach (xrange(1, 1000000) as $num) {
 echo $num, "\n";
}

$range = xrange(1, 1000000);
var_dump($range); // object(Generator)#1
var_dump($range instanceof Iterator); // bool(true)

利用yield简便、高效的生成fibonacci数列而不是循环或递归

<?php
function fibonacci($count) {
 $prev = 0;
 $current = 1;

 for ($i = 0; $i < $count; ++$i) {
 yield $prev;
 $next = $prev + $current;
 $prev = $current;
 $current = $next;
 }
}

foreach (fibonacci(48) as $i => $value) {
 echo $i , ' -> ' , $value, PHP_EOL;
}

利用yield来循环读取文件，而不需要像file函数那样一次性加载进来，节省内存

<?php
function file_lines($filename) {
 $file = fopen($filename, 'r'); 
 while (($line = fgets($file)) !== false) {
 yield $line; 
 } 
 fclose($file); 
}
 
foreach (file_lines('somefile') as $line) {
 // do some work here
}

yield除了能够返回值，用作变量时还可以接收值。

<?php
function logger($fileName) {
 $fileHandle = fopen($fileName, 'a');
 while (true) {
 fwrite($fileHandle, yield . "\n");
 }
}

$logger = logger(__DIR__ . '/log');
$logger->send('Foo');
$logger->send('Bar');

由于yield具有中断执行后再次调用又可以从中断处执行，外界又可以通过生成器对象（generator）的send方法进行交互，可以用于协程（coroutine），作多任务协作的流程控制。这里有个例子：

<?php
class Task {
 protected $taskId;
 protected $coroutine;
 protected $sendValue = null;
 protected $beforeFirstYield = true;

 public function __construct($taskId, Generator $coroutine) {
 $this->taskId = $taskId;
 $this->coroutine = $coroutine;
 }

 public function getTaskId() {
 return $this->taskId;
 }

 public function setSendValue($sendValue) {
 $this->sendValue = $sendValue;
 }

 public function run() {
 if ($this->beforeFirstYield) {
 $this->beforeFirstYield = false;
 return $this->coroutine->current();
 } else {
 $retval = $this->coroutine->send($this->sendValue);
 $this->sendValue = null;
 return $retval;
 }
 }

 public function isFinished() {
 return !$this->coroutine->valid();
 }
}

class Scheduler {
 protected $maxTaskId = 0;
 protected $taskMap = []; // taskId => task
 protected $taskQueue;

 public function __construct() {
 $this->taskQueue = new SplQueue();
 }

 public function newTask(Generator $coroutine) {
 $tid = ++$this->maxTaskId;
 $task = new Task($tid, $coroutine);
 $this->taskMap[$tid] = $task;
 $this->schedule($task);
 return $tid;
 }

 public function schedule(Task $task) {
 $this->taskQueue->enqueue($task);
 }

 public function run() {
 while (!$this->taskQueue->isEmpty()) {
 $task = $this->taskQueue->dequeue();
 $task->run();

 if ($task->isFinished()) {
 unset($this->taskMap[$task->getTaskId()]);
 } else {
 $this->schedule($task);
 }
 }
 }
}
function task1() {
 for ($i = 1; $i <= 10; ++$i) {
 echo "This is task 1 iteration $i.\n";
 yield;
 }
}

function task2() {
 for ($i = 1; $i <= 5; ++$i) {
 echo "This is task 2 iteration $i.\n";
 yield;
 }
}

$scheduler = new Scheduler;

$scheduler->newTask(task1());
$scheduler->newTask(task2());

$scheduler->run();

有些任务是需要交互进行的，如socket的监听和回复；有些任务异步执行又需要回调，如A执行不阻塞程序，但B执行又取决于A是否执行完毕。这些都可以使用yield来进行封装，达到流程控制的目的。

参考链接：
Generators overview
What does yield mean in PHP?
What is the difference between a generator and an array?
Cooperative multitasking using coroutines (in PHP!)
What Generators Can Do For You
Generators and Coroutines in PHP
Generators in PHP
协程与yield
http://www.hitoy.org/coroutine-and-yield.html
Co-operative PHP Multitasking
Generator (computer programming)
异步处理在分布式系统中的优化作用

PHP异步IO

Sat, 16 May 2015 12:08:24 +0800

为了能更快的响应请求，耗时任务的执行不能阻塞当前脚本执行，而是放在最后执行，比如fastcgi_finsh_request。现在又多了一个方法，PHP也可以进行异步IO处理了。

PHP扩展eio是基于C语言的libeio库中开发的异步IO处理，可用于异步文件读写，自定义异步任务执行。Nodejs使用的libuv库封装了libeio和libev（libev也有对应的PHP扩展：ev），前者提供异步IO，后者提供高性能的事件驱动，进行高性能的请求的处理。另外，PHP异步多线程框架Swoole也提供了异步IO处理的能力。

在CentOS下编译安装PHP eio扩展:

wget https://pecl.php.net/get/eio-1.2.5.tgz
tar -zxvf eio-1.2.5.tzg
cd eio-1.2.5
phpize
./configure
sudo make
sudo make install

更改php.ini添加扩展

[eio]
extension=eio.so

查看是否安装成功

注意：eio扩展必须在socket扩展之后加载，否则会提示’ undefined symbol: php_sockets_le_socket in Unknown on line 0’。

PHP eio支持libeio的所有操作，当调用eio_poll/eio_event_loop时，触发IO处理，处理完成进行回调；未主动调用eio_poll/eio_event_loop则不阻塞当前程序执行，等待脚本执行结束后在提交异步处理。使用eio_custom和eio_nop可以自定义异步任务调用。

以下以写文件进行比较，示例一是常规的文件写操作：

$strBasePath = dirname(__FILE__);
$strFileName = $strBasePath.'/file.log';
$strContent = 'something to log ...';

$nStart = microtime(true);
$rFile = fopen($strFileName ,'a+');
for($i=0;$i<1000;$i++){
	$nLength = fwrite($rFile, $strContent);
}
fclose($rFile);
echo "done\r\n";

register_shutdown_function(function(){
	global $nStart;
	echo microtime(true) - $nStart;
	echo "\r\n";
});

示例二是PHP eio的异步写操作：

$strBasePath = dirname(__FILE__);
$strFileName = $strBasePath.'/file.log';
$strContent = 'something to log ...';
$nLenth = strlen($strContent);

function eioOpenCallBack($p_mxData ,$p_mxResult){
	//echo "Open.\r\n";
	if ($p_mxResult > 0) {
		eio_fstat($p_mxResult, EIO_PRI_DEFAULT, "eioStatCallBack", $p_mxResult);
	}
}
function eioStatCallBack($p_mxData ,$p_mxResult){
	global $strContent ,$nLenth;
	//echo "Stat.\r\n";
	if ($p_mxResult > 0) {
		eio_write($p_mxData, $strContent, $nLenth, $p_mxResult['size'], EIO_PRI_DEFAULT, "eioWriteCallBack", $p_mxData);
	}
}
function eioWriteCallBack($p_mxData ,$p_mxResult){
	//echo "Write.\r\n";
	if ($p_mxResult > 0) {
		eio_close($p_mxData, EIO_PRI_DEFAULT, "eioCloseCallBack", $p_mxData);
	}
}
function eioCloseCallBack($p_mxData ,$p_mxResult){
	//echo "Close.\r\n";
	if($p_mxResult == 0){
		//echo "End\r\n";
	}
}

$nStart = microtime(true);
for($i=0;$i<1000;$i++){
	eio_open($strFileName, EIO_O_CREAT | EIO_O_RDWR, EIO_S_IRUSR | EIO_S_IWUSR,EIO_PRI_DEFAULT, "eioOpenCallBack", $strFileName);
	
	//echo "Begin\r\n";
	
	//eio_event_loop();
}
echo "done\r\n";
register_shutdown_function(function(){
	global $nStart;
	echo microtime(true) - $nStart;
	echo "\r\n";
});

示例三是swoole扩展的异步写操作

$strBasePath = dirname(__FILE__);
$strFileName = $strBasePath.'/file.log';
$strContent = 'something to log ...';

$nStart = microtime(true);
for($i=0;$i<1000;$i++){
	swoole_async_write($strFileName ,$strContent);
}
echo "done\r\n";
register_shutdown_function(function(){
	global $nStart;
	echo microtime(true) - $nStart;
	echo "\r\n";
});

对比情况

可以看出，eio和swoole提交异步IO处理后，处理非常快，并未阻塞当前进程运行；eio更像是只花了循环的时间。swoole只能运行于CLI模式，使用了Linux Native AIO，处理非常快，写法也比较简单。eio可以运行于CGI和CLI模式，提交异步处理后会创建至多4个线程（eio_nthreads）进行处理，处理完成后仍然会返回主线程，所以PHP脚本执行结束后，主线程仍然会在在那里等待。eio的异步处理通过回调进行保证，写法上更加复杂。这就需要对异步回调进行包装，提供类似同步的代码，参见协程。

参考链接：
PHP异步执行长时间任务
 PHP的生命周期
 libeio源码学习
 PHP新增eio扩展，可以写类似node.js一样的异步IO了
 深入浅出Node.js（五）：初探Node.js的异步I/O实现
 异步AIO的研究
 关于C10K、异步回调、协程、同步阻塞
 协程
 linux AIO （异步IO）那点事儿
 什么程序设计语言机制是处理异步 IO 最恰当的抽象？
nodejs异步IO的实现
 向facebook学习，通过协程实现mysql查询的异步化
 Python 中的进程、线程、协程、同步、异步、回调
 一个“蝇量级” C 语言协程库

CentOS上安装Nginx+PHP-FPM

Sun, 10 May 2015 11:06:08 +0800

Nginx是一个高性能、轻量级的HTTP服务器，占用内存少，稳定性高，也可做为反向代理服务器。Nginx采用事件驱动，在Linux操作系统下，Nginx使用epoll事件模型，充分使用异步逻辑，削减了上下文调度开销，并发服务能力更强。

PHP-FPM是PHP的FastCGI 进程管理器，具有一些高级特性，将PHP进程管理与Web服务器分开，可以分开部署在不同机器上，监听不同的端口和使用不同的 php.ini 配置文件。

PHP-FPM特性之一：fastcgi_finish_request能够在请求完成和刷新数据后，继续在后台执行耗时的工作（录入视频转换、统计处理等），达到分离执行后台任务而又不阻塞PHP快速响应，可作为PHP性能优化点。

PHP-FPM另一特性：可以记录请求当中慢响应的日志，类似Mysql满日志，包括文件名，函数名，行号等，可用于分析PHP的性能问题。

在Apache + mod_php下，每一个请求，Apache便会启动一个进程并加载php解释器来处理。在Nginx + PHP-FPM下，Nginx将PHP请求和环境变量通过socket传递给FastCGI进程；将静态资源请求则缓存到本地并返回。FastCGI 进程管理器采用固定静态（或动态）的子进程来处理请求，占用内存少，具有更好的扩展能力。

在CentOs 6.4上安装Nginx和PHP-FPM：

yum search nginx
sudo yum install nginx
sudo chkconfig --levels 235 nginx on
sudo service nginx start

yum search fpm
sudo yum install php54-fpm

编辑php.ini

sudo vim /etc/php.ini

; cgi.fix_pathinfo provides *real* PATH_INFO/PATH_TRANSLATED support for CGI. PHP's
; previous behaviour was to set PATH_TRANSLATED to SCRIPT_FILENAME, and to not grok
; what PATH_INFO is. For more information on PATH_INFO, see the cgi specs. Setting
; this to 1 will cause PHP CGI to fix its paths to conform to the spec. A setting
; of zero causes PHP to behave as before. Default is 1. You should fix your scripts
; to use SCRIPT_FILENAME rather than PATH_TRANSLATED.
; http://www.php.net/manual/en/ini.core.php#ini.cgi.fix-pathinfo
cgi.fix_pathinfo=0

启动PHP-FPM

chkconfig --levels 235 php-fpm on
service php-fpm start

更改Nginx worker_processes配置

sudo vim /etc/nginx/nginx.conf

worker_processes 4;

更改Nginx 配置以便处理php请求

sudo vim /etc/nginx/conf.d/default.conf

server {
 listen 80 default_server;
 server_name _;

 #charset koi8-r;

 #access_log logs/host.access.log main;

 # Load configuration files for the default server block.
 include /etc/nginx/default.d/*.conf;

 location / {
 root /usr/share/nginx/html;
 index index.html index.htm;
 }

 error_page 404 /404.html;
 location = /404.html {
 root /usr/share/nginx/html;
 }

 # redirect server error pages to the static page /50x.html
 #
 error_page 500 502 503 504 /50x.html;
 location = /50x.html {
 root /usr/share/nginx/html;
 }

 # proxy the PHP scripts to Apache listening on 127.0.0.1:80
 #
 #location ~ \.php$ {
 # proxy_pass http://127.0.0.1;
 #}

 # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
 #
 location ~ \.php$ {
 root /usr/share/nginx/html;
 #fastcgi_pass 127.0.0.1:9000;
 fastcgi_pass unix:/tmp/php5-fpm.sock;
 fastcgi_index index.php;
 fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
 include fastcgi.conf;
 }

 # deny access to .htaccess files, if Apache's document root
 # concurs with nginx's one
 #
 #location ~ /\.ht {
 # deny all;
 #}
}

编辑PHP-FPM

sudo vim /etc/php-fpm.d/www.conf

; List of ipv4 addresses of FastCGI clients which are allowed to connect.
; Equivalent to the FCGI_WEB_SERVER_ADDRS environment variable in the original
; PHP FCGI (5.2.2+). Makes sense only with a tcp listening socket. Each address
; must be separated by a comma. If this value is left blank, connections will be
; accepted from any ip address.
; Default Value: any
;listen.allowed_clients = 127.0.0.1
listen = /tmp/php5-fpm.sock

; Set permissions for unix socket, if one is used. In Linux, read/write
; permissions must be set in order to allow connections from a web server. Many
; BSD-derived systems allow connections regardless of permissions.
; Default Values: user and group are set as the running user
; mode is set to 0660
listen.owner = nginx
listen.group = nginx
listen.mode = 0660

; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;	will be used.
; RPM: apache Choosed to be able to access some dir as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx

重启PHP-FPM

sudo service php-fpm restart

创建PHP页面

sudo vim /usr/share/nginx/html/info.php

<?php
phpinfo();

重启Nginx

sudo service nginx restart

测试PHP是否正确处理。

参考链接：
Nginx and PHP-FPM Configuration and Optimizing Tips and Tricks
nginx
FastCGI 进程管理器（FPM）
Apache + mod_php compared to Nginx + php-fpm
Which PHP mode? Apache vs CGI vs FastCGI
PHP: What are the advantages of FastCGI over mod_php?
What are the advantages of using PHP-FPM + Nginx over Apache and mod_php?
How To Install Nginx With PHP5 (And PHP-FPM) And MySQL Support On CentOS 6.5
How To Install Linux, nginx, MySQL, PHP (LEMP) stack on CentOS 6
Linux上配置Nginx+PHP5(FastCGI)
使用fastcgi_finish_request提高页面响应速度
 善用php-fpm的慢执行日志slow log，分析php性能问题
 swoole之代码热更新实现

PHP 扩展开发之Zephir

Wed, 06 May 2015 21:26:24 +0800

最近对代码进行性能分析后，发现两个耗时的地方：自动加载文件数太多；参数验证函数调用超过1000次。这也是许多php语言框架面临的问题，所以发展出来诸如Yaf，Swoole，Phalcon这些C语言扩展框架，或者类似workerman，reactphp，phpdaemon这些一次加载的框架。总之减少加载文件，使用内置函数，减少损耗，以提升性能。
相比之下，PHP扩展的框架性能还是要比PHP语言框架还要好不少。以往PHP扩展的开发方式就是C/C++，SWIG，现在还多了一个选择：zephir，从Phalcon发展出来的项目，采用类似PHP语法的中间语言，将代码编译为高性能的C扩展。zephir支持面向对象编程，变量类型除了类似PHP的动态类型，还支持静态类型（有点像FackBook的hack了）,而且可以调用php内置或其他C扩展的函数。zephir编译流程如下

整个过程是zephir和底层编译器自动进行编译优化的，当然也可以自己调整以获得更好的性能。
在ubuntu下的安装如官方教程即可，在centos下的安装如下：

su -c 'yum update'
sudo yum install -y wget 
sudo yum install -y vim 
sudo yum install -y libtool
sudo yum install -y gcc 
sudo yum install -y make 
sudo yum install -y re2c

sudo rpm -Uvh https://mirror.webtatic.com/yum/el6/latest.rpm
sudo yum install -y php55w 
sudo yum install -y php55w-devel 
sudo yum install -y php55w-json

sudo yum install -y git-core 

git clone https://github.com/json-c/json-c.git
cd json-c
./autogen.sh
./configure
make
make install

git clone https://github.com/phalcon/zephir
cd zephir
./install -c
zephir help

安装完成如下：

按照教程创建示例：

zephir init utils
cd utils
sudo vim utils/greeting.zep

greeting.zep代码如下：

namespace Utils;

class Greeting
{

 public static function say()
 {
 echo "hello world!";
 }

}

编译安装

$ zephir build

注意，我在php5.3下面这么编译都不行，在php5.5/php5.4的版本基本没有碰到什么问题。
然后更改php.ini：

sudo vim /etc/php.ini

在php.ini中加上以下内容

;zephir编译的扩展需要依赖json.so，需要提前加载
[json]
;如果php.ini中没有则加上，有则去掉;
extension=json.so

[utils]
extension=utils.so

查看php可用扩展

php -i

注意：如果提示’undefined symbol: php_json_decode_ex in Unknown on line 0’，则是php json扩展未加载，在php.ini打开就行了。加载了json.so后又提示’PHP Warning: Module ‘json’ already loaded’，则是已经在其他地方加载了该扩展，找出并注释掉。我的是在php.d下面的json.ini里面：

sudo vim /etc/php.d/json.ini

[json]
;已经在php.ini中加载了，为避免重复加载注释掉
;extension = json

加载成功后的效果：

创建一个php脚本来试一下

cd ~/utils
sudo vim greeting.php

greeting.php代码如下：

<?php

echo Utils\Greeting::say(), "\n";

保存并运行：

至此你的zephir编译的扩展已经成功了，赶紧翻译你的PHP代码去吧。
参考这篇教程，计算斐波拉契数列在我的环境下是这样的：

性能提升还是挺明显的，而且在静态类型（强类型）下面还能比动态类型再提升。

参考链接：
开源的 PHP 轻量级框架 iphp
自己写PHP扩展之创建一个类
 快速开发一个PHP扩展
 CentOS 5 or CentOS 6 Upgrade PHP to PHP 5.4 or PHP 5.5
PHP 開發者應該將 Zephir 列為重要觀察的專案
 Hack: a new programming language for HHVM
PHP-CPP
Getting Started with PHP Extension Development via Zephir
Quick Tip: Install Zephir and Phalcon 2 on Vagrant

PHP unserialize出错

Sun, 12 Oct 2014 17:03:15 +0800

最近碰到一个问题，在使用PHP的unserialize函数反序列化服务端传递过来的参数时报错了：unserialize() [function.unserialize]: Error at offset 180 of 181 bytes。最后在Stackoverflow上找到了一个非常好的答案：这是由于序列化时字符串长度算错了导致的。作者还写了个校正长度的正则表达式，提供了一个用于计算序列化是否出错了的函数。导致序列化出错的原因通常是因为内容使用了双引号（”）而不是单引号（’），php与mysql编码不一致（UTF8），内容包括冒号（:）和引号（;）也会导致反序列化出错。
解决的方法是在serialize上加上base64函数，对数据做base64编码和解码：

$toDatabse = base64_encode(serialize($data));
$fromDatabase = unserialize(base64_decode($data));

当然更建议使用json_encode和json_decode的来处理数据的序列化和反序列化会更快，但有一些局限性（这里）。

之前有碰到URL参数传递时base64_encode/base64_decode的坑，可以像下面这样处理：

function base64url_encode($s) {
 return str_replace(array('+', '/'), array('-', '_'), base64_encode($s));
}

function base64url_decode($s) {
 return base64_decode(str_replace(array('-', '_'), array('+', '/'), $s));
}

参考链接：
unserialize() [function.unserialize]: Error at offset
PHP Serialize() & Unserialize() Issues
Handling a PHP unserialize offset error… and why it happens
PHP – Safely serialize and unserialze arrays
Why is base64_encode() adding a slash “/” in the result?
d

PHP 和 Mysql 日期问题

Thu, 22 Aug 2013 22:10:17 +0800

最近在php 和 mysql上碰到了一个计算日期Bug：在mysql中使用date_add计算日期，比如date_add(now(),interval 30 year)，然后保存进去的值就变成了’0000-00-00 00:00:00’；在php 中使用strtotime计算日期，比如(‘2143-08-22 15:23:56 -100 year’)，然后格式化后就变成了’1970-01-01 ‘。后来google了下，发现这是著名的2038年问题。
这个问题是因为在32位操作系统上日期类型是一个有正负号的32位整数，2147483647 是能表示的最大32为正整数，对应2038-01-19 03:14:07，超出了就“绕回”，所以不能正常处理。

怎么解决这个问题呢？使用64位的操作系统，这样子日期类型宽度就有64位了，能表示的日期就更大了。但是目前仍然有大量的程序运行在32为操作系统上，在php和mysql中要怎么处理呢？
在php中就不能使用strtotime来转换时间，因为它可能超出了。正确应该是用DateTime来处理时间。

$end=new DateTime('now');
$end->modify('20');
echo $end->format('Y-m-d');

$to=new DateTime('2100-08-22 21:40:00');
$interval=$end->diff($to);
echo $interval->format('%R%y 年');

在mysql中应该使用datetime来保存超过2038年的日期。timestamp和datetime的区别是:

datetime类型能够保存从1000-01-01 00:00:00至9999-12-31 23:59:59；timestamp只能保存从1970-01-01 00:00:01至2038-01-19 03:14:07。timestamp的保存范围小，在2038-01-19 03:14:07过后将会溢出，而datetime则不会。

timestamp是一个时间戳，能够使用CURRENT_TIMESTAMP来进行填充，而datetime则不行。

timestamp是跟时区相关的，在改变时区后，保存的值也会做相应的改变。而datetime保存的值是不会因为时区改变而改变。

所以如果要保存日期超过2038年的就选择datetime类型，如果是想在做update/inset是做一个自动日期记录而不关心日期的加减就选择timestamp。

参考链接
2038年问题
 PHP & mySQL: Year 2038 Bug: What is it? How to solve it?
PHP Date and Time
PHP: strtotime is returning false for a future date?
Mysql DATE, DATETIME, and TIMESTAMP Types
Mysql时间字段格式如何选择，TIMESTAMP，DATETIME，INT？
Datetime vs Timestamp in MySQL and PHP in practice?

PHP __destruct函数

Sun, 04 Aug 2013 22:34:24 +0800

PHP引擎会在脚本执行完成后进行垃圾回收，那么是否还需要destruct呢？在stackoverflow上看到的一个很好的答复：

析构函数本身跟内存释放没有任何直接的关系，它只是当一个对象被回收时执行自定义代码的“钩子”。它的作用跟构造函数刚好相反-构造函数本身也不申请内存（内存的申请和释放都是GC的事）。
GC能够很好的管理PHP原生的资源（比如对象），但是对于外部资源却必须手动处理。比如，一个文件管理的类，析构函数的作用就是保证如果文件被打开了，就应该被关闭。虽然“最好”在一个对象上要求去调用一个关闭或处理操作，这时析构函数就作为一种援助机制。
我本身反对将析构函数与GC一起使用。有许多微妙的问题他们可以引入如明显的非确定性和意外的能力保持对象存活——甚至在像PHP这种使用引用计数的语言里面。（Java/JVM和.net使用终结器更为挑剔。）

总结下，就是析构函数本身跟垃圾回收没有什么关系，但它应该用来确保一些外部资源被关闭，比如文件操作和数据库连接。
在一个项目中，我们可能只会使用一个数据库连接类，但是我们又不能随时关闭它，因为不能确定其他的地方是否有用到，那么就在析构函数里确保它关闭，否则PHP也不会手动去释放它，否则可能会经常遇到Mysql达到最大连接数的问题。为什么需要手动去释放资源呢？可以参阅鸟哥的文章。

参考链接：
Is the __destruct method necessary for PHP?
请手动释放你的资源(Please release resources manually)
[原创] 从 PHP 代码分析 PHP 的 GC(垃圾回收) 机制
 PHP 垃圾回收机制

PHP strtotime计算月份

Mon, 29 Jul 2013 22:15:52 +0800

今天同事发现了一个php的月份bug，说月份列表里怎么出现了两个3月份，代码是大概是这样的：

$month[]=date('Y年m月',strtotime('today'));
$month[]=date('Y年m月',strtotime('-1 month'));
$month[]=date('Y年m月',strtotime('-2 month'));
$month[]=date('Y年m月',strtotime('-3 month'));
$month[]=date('Y年m月',strtotime('-4 month'));
$month[]=date('Y年m月',strtotime('-5 month'));

利用strtotime来计算最近了六个月份，这个bug之前没有被发现因为只有在每月的29，30，31号才会发作：因为php默认取当前时间来做计算，比如今天7月29号减去5个月应该是2月29号，因为今年的2月份没有29号，所以就到了3月份了。

于是修改了下：

$month[]=date('Y年m月',strtotime('today'));
$month[]=date('Y年m月',strtotime('first day of -1 month'));
$month[]=date('Y年m月',strtotime('first day of -2 month'));
$month[]=date('Y年m月',strtotime('first day of -3 month'));
$month[]=date('Y年m月',strtotime('first day of -4 month'));
$month[]=date('Y年m月',strtotime('first day of -5 month'));

但是这个只有在php 5.3以上的版本中才会起作用，在php 5.2的版本有bug，需要这样处理：

$month[]=date('Y年m月',strtotime('today'));
$month[]=date('Y年m月',mktime(0,0,0,date('n')-1,1,date('Y')));
$month[]=date('Y年m月',mktime(0,0,0,date('n')-2,1,date('Y')));
$month[]=date('Y年m月',mktime(0,0,0,date('n')-3,1,date('Y')));
$month[]=date('Y年m月',mktime(0,0,0,date('n')-4,1,date('Y')));
$month[]=date('Y年m月',mktime(0,0,0,date('n')-5,1,date('Y')));

参考链接：
php strtotime函数
 Version difference for strtotime(‘first day of last month’)?

PHP base64_decode 空格问题

Sun, 02 Jun 2013 17:42:34 +0800

php对一个base64_encode编码后的字符串通过url传递后进行base64_decode发现返回值是false。尝试将url传递后的值打印出来发现+都被换成了空格。上网查了下发现，对于通过application/x-www-form-urlencoded的HTTP传递值，+会被自动替换为空格。所以也有各种对base64编码进行扩充的，比如对+,/等符号进行替换的，以便HTTP传输。在php中需要将+号或空格做退还，比如简单的str_replace(‘ ‘,’+’,$str)或者在传输前做urlencode。

参考链接：
Strange Base64 encode/decode problem
Base64

PHP安全问题

Fri, 29 Mar 2013 16:42:59 +0800

在乌云漏洞平台上发现很多开源PHP程序存在漏洞。大部分漏洞都是因为对PHP中的变量过滤不够严格和未转义造成，直接使用了$_GET，$_PUT，$_COOKIE传过来的值，造成了sql注入（sql injection）和跨站攻击（xss）。事实上这些漏洞完全可以避免的。
先说sql注入。通常注入情况发生在参数过滤不严谨和拼接sql，所以尽量不要用sql拼接，尽量使用PDO或Mysqli。

先看下面一段代码（test.php）：

$database="test";
$duser="root";
$dpassword="*********";
$server="localhost";
$link=mysql_connect($server,$duser,$dpassword) or die("连接不上服务器：".mysql_error());
mysql_select_db($database,$link) or die("不能选择数据库");

$id=$_GET['id'];
$sql="select id,account,nickname,password from user where id='".$id."'";
echo $sql;
$res=mysql_query($sql);
$arr=mysql_fetch_array($res,MYSQL_ASSOC);

然后访问http://127.0.0.1/test.php?id=1，获取用户信息。这是可以通过构造参数进行攻击比如

//访问：http://127.0.0.1/test.php?id=1%27%20OR%201%20=%201--%27
//将可以查询出所有的表数据。
$sql="select id,account,nickname,password from user where id='1' OR 1 = 1--''";

//访问：http://127.0.0.1/test.php?id=1%27%20UNION%20ALL%20%28SELECT%20NULL,NULL,NULL,%27%3C?php%20system%28$_GET[%22command%22]%29;%20?%3E%27%20INTO%20OUTFILE%20%27D:/www/shell.php%27%29%20--%20-%27
//在知道网站路径情况下，在网站目录下生成shell.php，将能够在对用户的网站进行挂马，提权的操作。
$sql="select id,account,nickname,password from user where id='1' UNION ALL (SELECT NULL,NULL,NULL,'' INTO OUTFILE 'D:/www/shell.php') -- -''";

甚至还可以进行表数据的增加，修改，删除，数据库的删除！所以永远不要相信用户的输入，永远要过滤输入，转义输出。对传递过来的数字型变量要进行严格的匹配，对字符串型的变量进行长度限制。注意过滤用户传递过来的变量是否包含引号，/*，#，—等特殊字符或转义字符，script，drop，不要给用户超级权限，最好进行分隔。

//使用addslashes过滤单引号，双引号和斜杠
$uname = addslashes( $_GET['id'] );
$query = 'SELECT username FROM users WHERE id = "' . $uname . '";

//使用mysql_real_escape_string过滤特殊字符，比如\x00, \n, \r, \, ', ",\x1a
//mysql_real_escape_string使用的是本地单字节字符集，而我们传递多字节编码的变量时，有可能还是会造成SQL注入漏洞
//如chr(0xbf) . chr(0x27)，所以mysql服务端与php客户端通信尽量使用utf-8而不是gbk
$uname = mysql_real_escape_string( $_GET['id'] );
$query = 'SELECT username FROM users WHERE id = "' . $uname . '";

//使用is_numeric检查数字型变量
$id = $_GET['id'];
( is_numeric( $id ) ? TRUE : FALSE );

//使用sprintf格式化数字型变量
$id = $_GET['id'];
$query = sprintf("SELECT username FROM users WHERE id = '%d' ", $id);

//使用htmlentities($var, ENT_QUOTES)转义所有的html标记
$id = $_GET['id'];
$id = htmlentities( $id, ENT_QUOTES, 'UTF-8' );
 
$query = 'SELECT username FROM users WHERE id = "' . $id . '"';

//使用filter_var过滤script标签，防止xss
//$str = strip_tags($input);
$str = filter_var($input, FILTER_SANITIZE_STRING);

如果PHP支持PDO可以的话，就不要拼接sql，尽量使用PDO或Mysqli。使用PDO要在PDO的DSN中指定charset属性，要设置PDO::ATTR_EMULATE_PREPARES参数为false，禁止php进行本地转义，造成双字节转义攻击，如果没有必要，msyql服务端与php客户端应该都是用utf-8进行通信，而不是gbk。

$pdo = new PDO("mysql:host=192.168.0.1;dbname=test;","root");
$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
 
$st = $pdo->prepare("select * from info where id =? and name = ?");
$id = 21;
$name = 'zhangsan';
 
$st->bindParam(1,$id);
$st->bindParam(2,$name);
$st->execute();
$st->fetchAll();

除了过滤，变量务必初始化，不要自动获得变量，用户将可以构造任何变量进行攻击。
不要这样随意，将造成文件包含攻击

<?php
 if($_GET['page']) {//if(file_exists($_GET['page'])) {非严格的检测 http://localhost/index.php?page=/etc/passwd%00
 include($_GET['page']);
 }
?>

要进行严格的匹配，或者做映射

<?php
 if($_GET['page'] == 'news') {
 include('news.php');
 }
?>

关闭浏览器输出的错误报告，避免泄漏文件目录路径，错误报告应输出到日记文件中

#php.ini
display_errors = 'off'

#apache2.conf
php_flag display_errors off

php当中

ini_set('display_errors', false);

页面的访问要设置权限，特别是执行查询的或者录入的页面，简单设置如下

define('APP_ADMIN', '1');
if(!defined('APP_ADMIN')) exit;

应该做一个更为完善的权限系统，如基于角色的权限管理系统，最好细致到页面（元素）。
eval函数针对php安全有很大杀伤力，为了防止挂马，应禁用eval函数。
下载的页面必须设置下载目录，对要下载的文件进行检测或做目录权限控制，生成临时下载链接，不允许下载任意的文件。对于系统配置文件，日记文件等要做分离，建议像zend framework那样设置web目录，程序与web目录分开，避免泄漏源码等。不要将.svn文件直接放置在web目录，会导致源码泄露。
上传的页面必须进行类型检测，不要只截取扩展名，设置权限，不允许可执行文件。这里是网友写的一个文件类型检查类

/*通过文件名，获得文件类型*
 *@author chengmo QQ:8292669*
 *@copyright <a href="http://www.cnblogs.com/chengmo">http://www.cnblogs.com/chengmo</a> 2010-10-17
 *@version 0.1
 *$filename="d:/1.png";echo cFileTypeCheck::getFileType($filename); 打印：png
 */
class cFileTypeCheck
{
 private static $_TypeList=array();
 private static $CheckClass=null;
 private function __construct($filename)
 {
 self::$_TypeList=$this->getTypeList();
 }
 
 /**
 *处理文件类型映射关系表*
 *
 * @param string $filename 文件类型
 * @return string 文件类型，没有找到返回：other
 */
 private function _getFileType($filename)
 {
 $filetype="other";
 if(!file_exists($filename)) throw new Exception("no found file!");
 $file = @fopen($filename,"rb");
 if(!$file) throw new Exception("file refuse!");
 $bin = fread($file, 15); //只读15字节 各个不同文件类型，头信息不一样。
 fclose($file);
 
 $typelist=self::$_TypeList;
 foreach ($typelist as $v)
 {
 $blen=strlen(pack("H*",$v[0])); //得到文件头标记字节数
 $tbin=substr($bin,0,intval($blen)); ///需要比较文件头长度
 
 if(strtolower($v[0])==strtolower(array_shift(unpack("H*",$tbin)))) 
 {
 return $v[1];
 }
 }
 return $filetype;
 }
 
 /**
 *得到文件头与文件类型映射表*
 *
 * @return array array(array('key',value)...)
 */
 public function getTypeList()
 {
 return array(array("FFD8FFE1","jpg"),
 array("89504E47","png"),
 array("47494638","gif"),
 array("49492A00","tif"),
 array("424D","bmp"),
 array("41433130","dwg"),
 array("38425053","psd"),
 array("7B5C727466","rtf"),
 array("3C3F786D6C","xml"),
 array("68746D6C3E","html"),
 array("44656C69766572792D646174","eml"),
 array("CFAD12FEC5FD746F","dbx"),
 array("2142444E","pst"),
 array("D0CF11E0","xls/doc"),
 array("5374616E64617264204A","mdb"),
 array("FF575043","wpd"),
 array("252150532D41646F6265","eps/ps"),
 array("255044462D312E","pdf"),
 array("E3828596","pwl"),
 array("504B0304","zip"),
 array("52617221","rar"),
 array("57415645","wav"),
 array("41564920","avi"),
 array("2E7261FD","ram"),
 array("2E524D46","rm"),
 array("000001BA","mpg"),
 array("000001B3","mpg"),
 array("6D6F6F76","mov"),
 array("3026B2758E66CF11","asf"),
 array("4D546864","mid"));
 }
 
 	
 public static function getFileType($filename)
 {
 if(!self::$CheckClass) self::$CheckClass=new self($filename);
 $class=self::$CheckClass;
 return $class->_getFileType($filename);
 }
	
}

$filename="22.jpg";
echo $filename,"t",cFileTypeCheck::getFileType($filename),"rn";
$filename="11.doc";
echo $filename,"t",cFileTypeCheck::getFileType($filename),"rn";

对于暴力破解设置验证码，或者限制ip次数。

参考链接：
SQL Injection Attacks by Example
SQL Injection
Injection
PHP SQL Injection
PHP+MySQL环境下SQL Injection攻防总结
 PDO防注入原理分析以及使用PDO的注意事项
 SQL injection that gets around mysql_real_escape_string()
MySQL远程提权php版
 XSS Filter Evasion Cheat Sheet
php通过文件头检测文件类型通用类（zip,rar…)
php 验证码【倾斜，正弦干扰线，黏贴，旋转

在Yaf中应用Zend_Log

Tue, 19 Mar 2013 16:43:07 +0800

Zend Framework是Zend 官方用PHP写的一套MVC框架，里面包含了诸多组件，可以单独使用，但是在PHP的MVC框架中的性能评测中总是处于下风。在之前的项目中有使用过Zend Framework，对于结构和代码的规范有比较好的帮助，类库也非常全面，所以想在其他的一些项目中也能够应用到Zend Framework的一些Library。Yaf是国内牛人仿Zend Framework开发的一个PHP MVC框架的C扩展，性能较Zend Framework有巨大的提升，但是不如Zend Framework全面，更侧重于前端控制，大概后端用其方法来做更好。Yaf的文档少了些，而Zend Framework的应用则比较多，社区支持也更广泛。所以在新的项目采用了Yaf做为前端的分发管理器，结合Zend Framework的类库来进行开发。
本文是关于Zend_Log中添加Zend_Log_Writer_Firebug无效，不能输出到firebug的解决方法。其实这个问题刚好在其他项目中应用的时候也有碰到，之后在stackoverflow上找到了答案，原来是这个功能还依赖于Zend_Wildfire_Channel_HttpHeaders，又需要Zend_Controller_Request_Http和Zend_Controller_Response_Http。于是就仿着写了一个Yaf扩展，代码如下：

<?php
/**
 * Ap定义了如下的7个Hook,
 * 插件之间的执行顺序是先进先Call
 */
class WildfireChannelPlugin extends Yaf_Plugin_Abstract {

	public function routerStartup(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
	}

	public function routerShutdown(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
	}

	public function dispatchLoopStartup(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
		$this->_request = new Zend_Controller_Request_Http();
		$this->_response = new Zend_Controller_Response_Http();
		$this->_channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
		$this->_channel->setRequest($this->_request);
		$this->_channel->setResponse($this->_response);
		ob_start();
	}

	public function preDispatch(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
	}

	public function postDispatch(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
	}

	public function dispatchLoopShutdown(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
		if(isset($this->_channel)){
			$this->_channel->flush();
			$this->_response->sendHeaders();
		}
	}

}

然后在Bootstrap.php中注册扩展，代码如下:

	public function _initPlugin(Yaf_Dispatcher $dispatcher) {
		if(Yaf_Registry::get("config")->get("log")->get("firebug")){
			$WildfireChannel = new WildfireChannelPlugin();
			$dispatcher->registerPlugin($WildfireChannel);
		}
	}

之后，Zend_Log_Writer_Firebug和firebug就可以正常工作了。如果要在其他项目中应用，只需要在开始输出前和输出结束后，分别调用上面连个方法就可以了，比如在启动文件中：

class Boot{
	protected $_request;
	protected $_response;
	protected $_channel;
	protected function _initWildfireChannel(){
		$this->_request = new Zend_Controller_Request_Http();
		$this->_response = new Zend_Controller_Response_Http();
		$this->_channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
		$this->_channel->setRequest($this->_request);
		$this->_channel->setResponse($this->_response);
		ob_start();
	}
	public function __destruct(){
		if(isset($this->_channel)){
			$this->_channel->flush();
			$this->_response->sendHeaders();
		}
	}
}

然后按需打开WildfireChannel就可以了。
参考链接：
Zend_Log_Writer_Firebug() not working
高性能PHP框架 Phalcon
Zend Framework