我的陋室我做主

MySQL在线增量备份

2011-02-16T10:18:00.000+08:00

   增量备份的好处是可以节省备份的时间和占用的磁盘空间，可以根据业务和数据的特性，指定不同的全备和增量备份策略。

   备份最好是在slave上面进行，这样可以不对主库造成任何影响。使用xtrabackup这个工具能实现在线全备和在线增量备份，步骤如下：

   1、先做一个全备份
xtrabackup --backup --datadir=/data/iscsi/db/ --target-dir=/data/backups/mysql/

   2、每天增量备份

xtrabackup --backup --target-dir=/data/backups/inc/tue/ --incremental-basedir=/data/backups/mysql/ #Suppose the full backup is on Monday，Create an incremental backup on Tuesday

xtrabackup --backup --target-dir=/data/backups/inc/wed/ --incremental-basedir=/data/backups/inc/tue/ #Create an incremental backup on Wednesday

发生异常需要恢复时：

xtrabackup --prepare --apply-log-only --target-dir=/data/backups/mysql/ #Prepare the base backup from Monday

xtrabackup --prepare --apply-log-only --target-dir=/data/backups/mysql/ --incremental-dir=/data/backups/inc/tue/ #Roll Monday's data forward to the state on Tuesday

xtrabackup --prepare --apply-log-only --target-dir=/data/backups/mysql/ --incremental-dir=/data/backups/inc/wed/ #Roll forward again to the state on Wednesday

你可以用脚本程序和crontab一起来控制全备和增量备份的策略，将备份放在远程的服务器上面（可以在数据库服务器上面连接盘柜），达到数据安全的目的。

在线做MySQL slave

2011-02-15T10:43:00.000+08:00

之前给MySQL master做slave的时候，为了保证数据一致性，一般选择read lock或者停机，使用直接拷贝文件或者mysqldump的方法来实现。这种方法会使master在一段时间内不可写，影响业务的正常使用。

有没有更好的方法，可以在master可读写的情况下，生成一个数据没有差错的slave呢？用innobackupex可以实现。具体的原理可以去看文档。实现步骤如下：

   1. on slave：
   nc -l 9999 | cat - > /data/backups/backup.tar
   2. on master：
   innobackupex --stream=tar --slave-info ./ | nc desthost 9999
   3. on slave:
   cd /data/backups/
   tar -ixvf /data/backups/backup.tar
   innobackupex --apply-log --use-memory 5000M /data/backups

MySQL profile中'Sending data'很慢的问题

2010-12-27T17:56:00.001+08:00

这几天，对MySQL（5.0.77）数据库中一个几百行记录的表（用于任务分配，读写比较频繁），进行的一个简单查询，从1s逐渐增大到15s。

mysql> select id from t_task limit 1;

+----------+
| id |
+----------+
| 22865305 |
+----------+
1 row in set (15.24 sec)

Profiling的结果是：

mysql> show profile for query 1;
+--------------------------------+-----------+
| Status                         | Duration |
+--------------------------------+-----------+
| starting                       | 0.000014 |
| checking query cache for query | 0.000032 |
| Opening tables                 | 0.000012 |
| System lock                    | 0.000003 |
| Table lock                     | 0.000006 |
| init                           | 0.000010 |
| optimizing                     | 0.000003 |
| statistics                     | 0.000006 |
| preparing                      | 0.000004 |
| executing                      | 0.000003 |
| Sending data                   | 15.242734 |
| end                            | 0.000011 |
| query end                      | 0.000002 |
| freeing items                  | 0.000013 |
| logging slow query             | 0.000003 |
| logging slow query             | 0.000002 |
| cleaning up                    | 0.000002 |
+--------------------------------+-----------+
17 rows in set (0.00 sec)

从字面意思看，是慢在‘传输数据’这一步。

‘Sending data’的意义查不到具体的说明，这里http://forums.mysql.com/read.php?24,241461,242012#msg-242012有人说是：

Each time means the time elapsed between the previous event and the new event. So, the line:
| Sending data | 0.00016800 |
means that 0.00016800 seconds elapsed between "executing" and "Sending data". It is, it takes 0.00016800 seconds to execute the query.

可以在sql_select.cc里面看到源代码（在里面搜索Sending data），可以看到do_select的时间也算在‘sending data‘里面了。

所以这个‘sending data‘并不只是数据传输的时间，也包含select的时间。有人就这个语义含糊的问题给MySQL报过bug：http://bugs.mysql.com/bug.php?id=52492，但是不了了之。

这个问题最初怀疑是网卡有问题（这台机器之前网卡有问题，更新过驱动），但是新建一张表结构一样，数据量一样的表，做同样的查询，速度又很快。又怀疑是磁盘问题，因为根据pk的查询都很快（因为簇集索引所以都缓存在内存里面），vmstat和iostat都没有发现异常。

准备晚上升级MySQL，并使用HP BL460刀片机替换这台出过硬件故障的IBM x3650M2。

动态控制MySQL慢查询日志的设置

2010-11-29T15:04:00.000+08:00

To control the slow log at runtime, use the global slow_query_log and slow_query_log_file system variables. Set slow_query_log to 0 (or OFF) to disable the log or to 1 (or ON) to enable it. Set slow_query_log_file to specify the name of the log file. If a log file already is open, it is closed and the new file is opened.Set long_query_time to specify the seconds。
设置完成后，你可以通过select @@slow_query_log来确认是否设置成功。

使用maatkit来迁移MySQL数据库

2010-11-29T14:14:00.001+08:00

迁移MySQL一般会用两种方法：1、停掉数据库，直接拷贝数据文件。这种方法比较简单，合适用在迁移到更好的服务器上面，MySQL的版本没有大的变化。2、锁住数据库，将数据dump出来，再重新导入新的数据库。

在第二种方法中，一般会用mysqldump来导出，用mysql来导入。这两个工具都是单线程的，所以在迁移表比较多的情况下，会影响速度。你可以使用Maatkit 里面的mk-parallel-dump和mk-parallel-restore来导出导入数据。这两个工具都是多线程，并且更好用。

步骤如下：

锁住需要导出数据的数据库：flush tables with read lock;
导出数据： ./mk-parallel-dump -udeploy -p123 -h172.28.29.209 --databases cloud --tables t_test --chunk-size 100000 --threads 8 --base-dir /data/dump_data --charset binary --no-gzip 。其中的chunk-size 100000是指每次导出的记录数为10w，那么一个1000w的表，就会执行100次SQL语句，生成100个数据文件； threads 8是指用8个线程来导出数据，优先导出大表；charset binary指定用二进制来导出数据，可以避免乱码的问题。
在要导入的数据库上面修改允许接收的最大包大小为100M，防止导入SQL语句被这个限制住而报错：set global max_allowed_packet=104857600;
导入数据：./mk-parallel-restore -udeploy -p123 -h172.28.28.90 --databases cloud --fast-index --threads 8 /sandata/cloud 。其中fast-index适用于innodb plugin和XtraDB，可以提高创建索引的速度（先插入数据，再创建索引。如果先创建索引，再插入数据，那么对于几千万表来说，后面的插入速度会很慢）。
解锁原有数据库，max_allowed_packet改回正常值。迁移完成。

ps:把数据导入innodb plugin 或者XtraDB时，可能会报错errno: 1478。解释在这里：http://dev.mysql.com/doc/innodb-plugin/1.0/en/innodb-compression-syntax-warnings.html，因为my.cnf里面指定了 innodb_strict_mode=1

[翻译]在Python中如何使用Linux的epoll

2010-11-29T09:49:00.000+08:00

google doc的发布地址是：https://docs.google.com/document/pub?id=1kH6JKRgAo6BDC3voKInN4TrSgqC0VVs9Op80xl5xGxw

序言

从2.6开始，Python包含了访问Linux epoll库的API。这篇文章用几个简单的python 3例子来展示下这个API。欢迎大家质疑和反馈。

阻塞socket编程示例

示例1用python3.0搭建了一个简单的服务：在8080端口监听HTTP请求，把它打印到控制台，并返回一个HTTP响应消息给客户端。

第9行：创建服务器socket。
第10行：允许在11行使用bind()来监听指定端口，即使这个端口最近被其他程序监听。没有这个设置的话，服务不能运行，直到一两分钟后，这个端口不再被之前的程序使用。
第11行：监听这台机器所有可用的IPv4地址上面的8080端口。
第12行：通知服务端socket开始接受来自客户端的连接。
第14行：这行代码直到接收到一个客户端连接才会完成。这时，服务端socket会在服务端机器上面创建一个新的socket，用来和客户端通信。这个新的socket在代码里面就是accept()调用返回的clientconnection 对象。返回的address对象代表着客户端的IP和端口。
第15-17行：组装从客户端传输过来的数据，直到HTTP请求完成。HTTP协议可以参考这里。
第18行：把请求打印到控制台，验证操作是否正确。
第19行：发送响应回客户端。
第20-22行：关闭和客户端的连接以及服务端监听socket。

官方howto中对python socket编程有更详细的描述。

Example 1 (All examples use Python 3)

1 import socket
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13
14 connectiontoclient, address = serversocket.accept()
15 request = b''
16 while EOL1 not in request and EOL2 not in request:
17 request += connectiontoclient.recv(1024)
18 print(request.decode())
19 connectiontoclient.send(response)
20 connectiontoclient.close()
21
22 serversocket.close()

示例2在15行增加了一个循环来不断的处理来自客户端的连接，直到用户中断（比如键盘中断）。这个例子更清楚的说明服务端socket从不和客户端交换数据。相反的，它接收客户端的连接，然后在这台服务器上面创建一个新的socket用来和客户端通信。

在23-24行的finally语句，可以确保服务端负责监听的socket会关闭，即使有异常发生。

Example 2

1 import socket
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13
14 try:
15 while True:
16 connectiontoclient, address = serversocket.accept()
17 request = b''
18 while EOL1 not in request and EOL2 not in request:
19 request += connectiontoclient.recv(1024)
20 print('-'*40 + '\n' + request.decode()[:-2])
21 connectiontoclient.send(response)
22 connectiontoclient.close()
23 finally:
24 serversocket.close()

异步socket的好处以及Linux epoll

示例2中的socket叫做阻塞socket，因为python程序会停止运行，直到一个event发生。16行的accept()调用会阻塞，直到接收到一个客户端连接。19行的recv()调用会阻塞，直到这次接收客户端数据完成（或者没有更多的数据要接收）。21行的send()调用也会阻塞，直到将这次需要返回给客户端的数据都放到Linux的发送缓冲队列中。

当一个程序使用阻塞socket时，常常使用一个线程（甚至是一个专门的程序）来进行各个socket之间的通信。主程序线程会包含接收客户端连接的服务端监听socket。这个socket一次接收一个客户端连接，把连接传给另外一个线程新建的socket去处理。因为这些线程每个只和一个客户端通信，所以处理时即便在某几个点阻塞也没有关系。这种阻塞并不会对其他线程的处理造成任何影响。

使用多线程、阻塞socket来处理的话，代码会很直观，但是也会有不少缺陷。它很难确保线程共享资源没有问题。而且这种编程风格的程序在只有一个CPU的电脑上面效率更低。

C10K问题探讨了一些替代选择，其一是使用异步socket。这种socket只有在一些event触发时才会阻塞。相反，程序在异步socket上面执行一个动作，会立即被告知这个动作是否成功。程序会根据这个信息决定怎么继续下面的操作由于异步socket是非阻塞的，就没有必要再来使用多线程。所有的工作都可以在一个线程中完成。这种单线程模式有它自己的挑战，但可以成为很多方案不错的选择。它也可以结合多线程一起使用：单线程使用异步socket用于处理服务器的网络部分，多线程可以用来访问其他阻塞资源，比如数据库。

Linux的2.6内核有一系列机制来管理异步socket，其中3个有对应的Python的API：select、poll和epoll。epoll和pool比select更好，因为Python程序不需要检查每一个socket感兴趣的event。相反，它可以依赖操作系统来告诉它哪些socket可能有这些event。epoll比pool更好，因为它不要求操作系统每次都去检查python程序需要的所有socket感兴趣的event。而是Linux在event发生的时候会跟踪到，并在Python需要的时候返回一个列表。因此epoll对于大量（成千上万）并发socket连接，是更有效率和可扩展的机制，可以看这里的图片。

带epoll的异步socket编程示例

程序中使用epoll的顺序大都如下：

创建一个epoll对象
告诉epoll对象监控指定socket的指定event
询问epoll对象自从上次查询以后有哪些socket可能有指定的event发生
在这些socket上面执行一些动作
告诉epool对象去修改socket列表和（或者）event监控
重复步骤3到5，直到完成
销毁epoll对象

示例3重复了示例2的功能，同时使用异步socket。这个程序更为复杂，因为一个线程要交错与多个客户端通信。

第1行：select模块包含epoll功能。
第13行：因为socket默认是阻塞的，所以需要使用非阻塞（异步）模式。
第15行：创建一个epoll对象。
第16行：在服务端socket上面注册对读event的关注。一个读event随时会触发服务端socket去接收一个socket连接。
第19行：字典connections映射文件描述符（整数）到其相应的网络连接对象。
第21行：查询epoll对象，看是否有任何关注的event被触发。参数“1”表示，我们会等待1秒来看是否有event发生。如果有任何我们感兴趣的event发生在这次查询之前，这个查询就会带着这些event的列表立即返回。
第22行：event作为一个序列（fileno，event code）的元组返回。fileno是文件描述符的代名词，始终是一个整数。
第23行：如果一个读event在服务端sockt发生，就会有一个新的socket连接可能被创建。
第25行：设置新的socket为非阻塞模式。
第26行：为新的socket注册对读（EPOLLIN）event的关注。
第31行：如果发生一个读event，就读取从客户端发送过来的新数据。
第33行：一旦完成请求已收到，就注销对读event的关注，注册对写（EPOLLOUT）event的关注。写event发生的时候，会回复数据给客户端。
第34行：打印完整的请求，证明虽然与客户端的通信是交错进行的，但数据可以作为一个整体来组装和处理。
第35行：如果一个写event在一个客户端socket上面发生，它会接受新的数据以便发送到客户端。
第36-38行：每次发送一部分响应数据，直到完整的响应数据都已经发送给操作系统等待传输给客户端。
第39行：一旦完整的响应数据发送完成，就不再关注读或者写event。
第40行：如果一个连接显式关闭，那么socket shutdown是可选的。本示例程序这样使用，是为了让客户端首先关闭。shutdown调用会通知客户端socket没有更多的数据应该被发送或接收，并会让功能正常的客户端关闭自己的socket连接。
第41行：HUP（挂起）event表明客户端socket已经断开（即关闭），所以服务端也需要关闭。没有必要注册对HUP event的关注。在socket上面，它们总是会被epoll对象注册。
第42行：注销对此socket连接的关注。
第43行：关闭socket连接。
第18-45行：使用try-catch，因为该示例程序最有可能被KeyboardInterrupt异常中断。
第46-48行：打开的socket连接不需要关闭，因为Python会在程序结束的时候关闭。这里显式关闭是一个好的代码习惯。

Example 3

1 import socket, select
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13 serversocket.setblocking(0)
14
15 epoll = select.epoll()
16 epoll.register(serversocket.fileno(), select.EPOLLIN)
17
18 try:
19 connections = {}; requests = {}; responses = {}
20   while True:
21 events = epoll.poll(1)
22 for fileno, event in events:
23   if fileno == serversocket.fileno():
24 connection, address = serversocket.accept()
25 connection.setblocking(0)
26 epoll.register(connection.fileno(), select.EPOLLIN)
27 connections[connection.fileno()] = connection
28 requests[connection.fileno()] = b''
29 responses[connection.fileno()] = response
30   elif event & select.EPOLLIN:
31 requests[fileno] += connections[fileno].recv(1024)
32 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
33 epoll.modify(fileno, select.EPOLLOUT)
34 print('-'*40 + '\n' + requests[fileno].decode()[:-2])
35   elif event & select.EPOLLOUT:
36 byteswritten = connections[fileno].send(responses[fileno])
37 responses[fileno] = responses[fileno][byteswritten:]
38 if len(responses[fileno]) == 0:
39 epoll.modify(fileno, 0)
40 connections[fileno].shutdown(socket.SHUT_RDWR)
41   elif event & select.EPOLLHUP:
42 epoll.unregister(fileno)
43 connections[fileno].close()
44 del connections[fileno]
45 finally:
46 epoll.unregister(serversocket.fileno())
47 epoll.close()
48 serversocket.close()

epoll有两种操作模式，称为边沿触发和水平触发。在边沿触发模式中，epoll.poll（）在读或者写event在socket上面发生后，将只会返回一次event。调用epoll.poll()的程序必须处理所有和这个event相关的数据，随后的epoll.poll()调用不会再有这个event的通知。当一个特定event的数据耗尽时，进一步尝试操作socket将导致一个异常。相反，在水平触发模式下，重复调用epoll.poll（）会重复通知关注的event，直到与该event有关的所有数据都已被处理。在水平模式下通常没有异常。

例如，假设一个服务端socket已经为一个epoll对象注册了读event。在边沿触发模式下，程序需要一直accept()新的socket连接，直到一个socket.error的异常发生。而在水平触发模式下，一个accept()调用后，epoll对象会被服务端socket再次询问是否有新的event，以确定下一个accept()是否应该被调用。

示例3使用水平触发模式，这是操作的默认模式。示例4演示了如何使用边沿触发模式。在示例4中，第25，36和45行引入循环，直到出现异常才退出（或者所有其他已知的数据都被处理）。第32，38和48行捕获预期的socket异常。最后，第16，28，41和51行添加EPOLLET掩码，用来设置为边沿触发模式。

Example 4

1 import socket, select
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13 serversocket.setblocking(0)
14
15 epoll = select.epoll()
16 epoll.register(serversocket.fileno(), select.EPOLLIN | select.EPOLLET)
17
18 try:
19 connections = {}; requests = {}; responses = {}
20   while True:
21 events = epoll.poll(1)
22 for fileno, event in events:
23   if fileno == serversocket.fileno():
24 try:
25   while True:
26 connection, address = serversocket.accept()
27 connection.setblocking(0)
28 epoll.register(connection.fileno(), select.EPOLLIN | select.EPOLLET)
29 connections[connection.fileno()] = connection
30 requests[connection.fileno()] = b''
31 responses[connection.fileno()] = response
32 except socket.error:
33   pass
34   elif event & select.EPOLLIN:
35 try:
36   while True:
37 requests[fileno] += connections[fileno].recv(1024)
38 except socket.error:
39   pass
40 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
41 epoll.modify(fileno, select.EPOLLOUT | select.EPOLLET)
42 print('-'*40 + '\n' + requests[fileno].decode()[:-2])
43   elif event & select.EPOLLOUT:
44 try:
45   while len(responses[fileno]) > 0:
46 byteswritten = connections[fileno].send(responses[fileno])
47 responses[fileno] = responses[fileno][byteswritten:]
48 except socket.error:
49   pass
50 if len(responses[fileno]) == 0:
51 epoll.modify(fileno, select.EPOLLET)
52 connections[fileno].shutdown(socket.SHUT_RDWR)
53   elif event & select.EPOLLHUP:
54 epoll.unregister(fileno)
55 connections[fileno].close()
56 del connections[fileno]
57 finally:
58 epoll.unregister(serversocket.fileno())
59 epoll.close()
60 serversocket.close()

这两种模式是类似的，水平触发模式常被用在移植使用select或者poll机制的应用程序时，而边沿触发模式可以用在当程序员不需要或不想要操作系统协助管理event状态时。

除了这两种操作模式，epoll对象也可以注册socket使用EPOLLONESHOTevent掩码。当使用这个选项时，注册的event只适用于一个epoll.poll()调用，调用之后它会自动从被监视的socket注册列表中移除。

性能注意事项

监听缓冲区队列大小

在示例1-4中，第12行都调用了serversocket.listen()方法。此方法的参数就是监听缓冲区队列的大小。它告诉操作系统可以接收多少TCP/IP连接，并放到缓冲区队列中等待Pytohn程序接收。Python程序每次在服务端socket上面调用accept()，就会有一个连接从缓冲区队列中移除，一个新的连接可以进入缓冲区队列。如果队列已满，新的连接都会被忽略，这会对网络连接的客户端造成不必要的延迟。在生产服务器上，通常要处理几十或几百个并发连接，所以值1通常是不够的。比如，当使用ab模拟100个并发HTTP 1.0客户端，对上面的几个示例进行负载测试，如果缓冲区队列的值小于50，就会引起性能下降。

TCP选项

TCP_CORK选项可以用来“封存”消息，直到他们准备好发送。如示例5的第34行和第40行所示，这个选项对于使用HTTP/1.1流水线技术的HTTP服务端来说，可能是一个很好的选择。

Example 5

1 import socket, select
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13 serversocket.setblocking(0)
14
15 epoll = select.epoll()
16 epoll.register(serversocket.fileno(), select.EPOLLIN)
17
18 try:
19 connections = {}; requests = {}; responses = {}
20   while True:
21 events = epoll.poll(1)
22 for fileno, event in events:
23   if fileno == serversocket.fileno():
24 connection, address = serversocket.accept()
25 connection.setblocking(0)
26 epoll.register(connection.fileno(), select.EPOLLIN)
27 connections[connection.fileno()] = connection
28 requests[connection.fileno()] = b''
29 responses[connection.fileno()] = response
30   elif event & select.EPOLLIN:
31 requests[fileno] += connections[fileno].recv(1024)
32 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
33 epoll.modify(fileno, select.EPOLLOUT)
34 connections[fileno].setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)
35 print('-'*40 + '\n' + requests[fileno].decode()[:-2])
36   elif event & select.EPOLLOUT:
37 byteswritten = connections[fileno].send(responses[fileno])
38 responses[fileno] = responses[fileno][byteswritten:]
39 if len(responses[fileno]) == 0:
40 connections[fileno].setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 0)
41 epoll.modify(fileno, 0)
42 connections[fileno].shutdown(socket.SHUT_RDWR)
43   elif event & select.EPOLLHUP:
44 epoll.unregister(fileno)
45 connections[fileno].close()
46 del connections[fileno]
47 finally:
48 epoll.unregister(serversocket.fileno())
49 epoll.close()
50 serversocket.close()

另一方面， TCP_NODELAY选项可以用来告诉操作系统，任何传递给socket.send()的数据，不再缓存，要立即发送给客户端。如示例6的14行所示，这个选项对于使用一个SSH客户端或其他“实时”应用来说，可能是一个很好的选择。

Example 6

1 import socket, select
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13 serversocket.setblocking(0)
14 serversocket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
15
16 epoll = select.epoll()
17 epoll.register(serversocket.fileno(), select.EPOLLIN)
18
19 try:
20 connections = {}; requests = {}; responses = {}
21   while True:
22 events = epoll.poll(1)
23 for fileno, event in events:
24   if fileno == serversocket.fileno():
25 connection, address = serversocket.accept()
26 connection.setblocking(0)
27 epoll.register(connection.fileno(), select.EPOLLIN)
28 connections[connection.fileno()] = connection
29 requests[connection.fileno()] = b''
30 responses[connection.fileno()] = response
31   elif event & select.EPOLLIN:
32 requests[fileno] += connections[fileno].recv(1024)
33 if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
34 epoll.modify(fileno, select.EPOLLOUT)
35 print('-'*40 + '\n' + requests[fileno].decode()[:-2])
36   elif event & select.EPOLLOUT:
37 byteswritten = connections[fileno].send(responses[fileno])
38 responses[fileno] = responses[fileno][byteswritten:]
39 if len(responses[fileno]) == 0:
40 epoll.modify(fileno, 0)
41 connections[fileno].shutdown(socket.SHUT_RDWR)
42   elif event & select.EPOLLHUP:
43 epoll.unregister(fileno)
44 connections[fileno].close()
45 del connections[fileno]
46 finally:
47 epoll.unregister(serversocket.fileno())
48 epoll.close()
49 serversocket.close()

源代码

此页面上的示例不受版权限制，这里提供下载。

MySQL enterprise Monitor的安装和使用

2010-05-31T17:26:00.001+08:00

上次内部分享MySQL经验的时候，西山居的DBA建议试用一下MySQL enterprise Monitor，游戏部门已经购买，并且评价很高。

抽空安装试用了一下，感觉挺好的，可以发现不少数据库存在的风险，推荐大家使用。

官方的文档挺全的，这里记录一下安装的过程。
   1、到https://enterprise.mysql.com/去申请一个试用版。
   2、安装监控访问管理端的程序（service manager and dashboard），这个我是安装在windows下的。一路next就行
3、增加agent的MySQL权限：
            grant select,replication client,show databases,super,process on *.* to ‘agent’@'127.0.0.1′ identified by ‘password’;
           grant create,insert on mysql.* to ‘agent’@'127.0.0.1′ identified by ‘password’;
4、安装agent端程序（mysqlmonitoragent），：
       rpm -qa | grep -i lsb 看redhat-lsb-3.1-12.3.EL是否存在（数据库操作系统为centos5.4）
       直接执行 mysqlmonitoragent-2.2.0.1705-linux-glibc2.3-x86-64bit-installer.bin --mode text即可。如果不需要agent采集SQL语句来分析，就不用开启MySQL Enterprise Agent Proxy Service。
5、/etc/init.d/mysql-monitor-agent start 启动agent。可以查看/opt/mysql/enterprise/agent/mysql-monitor-agent.log来看是否正常。
6、没问题的话，在server端的18080端口就可以看到数据库的监控情况了。

MySQL Query Browser的SQL语句耗时提示

2010-05-12T10:15:00.013+08:00

在MySQL Query Browser中执行一条SQL语句，会发现左下角有一行提示：

N row(s) fetched in Time1 s(Time2 s)

以前没有在意里面两个时间的区别，最近数据库（IBM x3650）网卡故障，访问很慢，在排除软件问题的时候，发现这两个时间比较诡异，有时Time1比Time2大很多。google了下，这里可以看到sun数据库工程师的解释：

query_time is the time the query needed to execute:

// Start query timer
timer_start(&timer);

if (sql)
r= myx_mysql_query(mysql, resultset->query->sql);
#if MYSQL_VERSION_ID >= 50000
else
r= mysql_next_result(mysql);
#endif
// Stop query timer
resultset->query_time= timer_stop(&timer);

and fetch_time is what it took to get the result set transferred to the client.

可以得知，Time1是服务器端把结果传回客户端的时间，Time2是数据库执行SQL语句的时间。

毒霸云查杀数据库架构和MySQL优化实践

2010-04-30T19:32:00.003+08:00

想写这个PPT很久了，毒霸的数据库规模和应用最大的就是云查杀这边，两三年间遇到的问题也挺多，有必要总结一下。这次参加2010数据库大会回来，要做内部分享，就抽了时间写了下（PPT是个提纲，等内部分享完了放录音出来）

http://www.slideshare.net/moonbingbing/mercury-4148606

[翻译]How to calculate a good InnoDB log file size

2010-04-14T20:43:00.003+08:00

原文在这里

Peter之前写了一篇文章：'选择合适的InnoDB日志文件大小'。不是挑peter的刺儿，这篇文章其实讲了挺多东西，但就是没有告诉你怎么选择合适的日志文件大小！所以我想澄清这一点。

基本的一点是，你的日志文件大小应该满足InnoDB优化自己的IO的需要，但是太大的话崩溃恢复时间就会变得很长。这一点peter已经讲的很清楚。怎么确定这个大小呢？我这里有一个相当不错的经验。

在大多数情况下，当别人给你一个公式来选择一个配置的时候，你应该对它持怀疑的态度。但是在这种情况下,你可以计算出一个合理的值，信不信由你。在你服务器的高峰期运行下面这些查询：

mysql> pager grep sequence
PAGER SET TO 'grep sequence'
mysql> SHOW engine innodb STATUS\G SELECT sleep(60); SHOW engine innodb STATUS\G
Log sequence number 84 3836410803
1 row IN SET (0.06 sec)
1 row IN SET (1 min 0.00 sec)
Log sequence number 84 3838334638
1 row IN SET (0.05 sec)

注意'log sequence number'，这个是已经写到事务日志中总的字节数。所以，现在你可以看到每分钟有多少MB写到日志文件中。（这种方法对MySQL的所有版本都有效。在5.0以上的版本中，可以用SHOW GLOBAL STATUS来观察Innodb_os_log_written的变化即可。最后有这种方法的介绍）

mysql> SELECT (3838334638 - 3836410803) / 1024 / 1024 AS MB_per_min;
+------------+
| MB_per_min |
+------------+
| 1.83471203 |

一个粗略的经验，你可以设置日志文件的大小，使它可以存放一个小时左右的日志。一小时的日志是足够应对InnoDB处理的大量数据,数据库就能在周期性的IO刷新和保存进度的过程中使用顺序写。以这样的速度,这个服务器会一共使用大约110MB的日志。为了好计算可以

把这个值约算到128M（2的倍数）。因为默认的日志文件有两个，所以除以二，你可以设置为：

 innodb_log_file_size=64M  

这个值是不是有点儿出乎你意料的小？可能吧，我经常看到这个参数设置上G的。但是大部分都是设置错了。我上面用来计算这个参数的数据库不是个玩具，是一个负载挺大的数据库。在生产环境中日志文件的大小当然不能用默认的5M，但是也往往没有你想象中的那么大。

如果你有一个写操作很繁忙的数据库（可能你会插入很多数据量很大的），根据这个经验计算你得到的日志文件应该为好几G。这种情况下你可能想让日志文件小一点儿，不用GB来做文件结尾。但你同时要意识到：恢复时间不只和日志文件的大小有关，也和日志文件包含的条目数有关系。如果你的日志中，每个条目都很大，但是条目数并不多，那么它的恢复比你预料中的大日志恢复要快很多。

但是在我用这种方法的大多数情况下，我最后都发现合适的日志大小都比当时数据库已经配置好的要小得多。一方面是因为InnoDB日志经过很好的压缩;另一个原因是通常对设置日志大小的建议是错误的：根据innodb_buffer_pool_size来设置它的大小。（就是my.cnf里面的"Set innodb_log_file_size to 25 %of innodb_buffer_pool_size"）

最后一个要注意的：很大的缓冲池或者异常繁忙的数据库可能需要更大（或者更小！）的日志大小。这就是公式的分解，需要更多的判断和经验。但是这个'经验法则'是一个很好的开端。

-------------------
附：怎么用Innodb_os_log_written来计算日志文件的大小。
mysql> SHOW GLOBAL STATUS  like 'Innodb_os_log_written';select sleep(60);SHOW GLOBAL STATUS  like 'Innodb_os_log_written';
+-----------------------+--------------+
| Variable_name         | Value        |
+-----------------------+--------------+
| Innodb_os_log_written | 291899526656 |
+-----------------------+--------------+
1 row in set (0.00 sec)

+-----------+
| sleep(60) |
+-----------+
|         0 |
+-----------+
1 row in set (1 min 0.08 sec)

+-----------------------+--------------+
| Variable_name         | Value        |
+-----------------------+--------------+
| Innodb_os_log_written | 291905601536 |
+-----------------------+--------------+
1 row in set (0.00 sec)

开放的安全平台

2010-04-11T23:30:00.003+08:00

国内杀软的竞争日趋白热化，瑞星已经是明日黄花，江民也面临被收购的命运，国外的巨头都在抢滩登陆，中小安全公司更是遍地开花。

现在最引人注目的就是云安全，每家都在宣传自己的云是多么的好，其实都差不多，听听就好了，不必太当真。

安全，是一个计算机用户都要面对的问题，每过几年这块蛋糕就有一次重新洗牌的机会。各个厂商在当下竞争的时候，也要关注下一步怎么走才能领先，不能被别人主导。

安全，对个人用户来说注定是要免费的，今年，2010，一定会全部免费。到时候，你靠什么赚钱？企业市场是国外杀软和瑞星的天下，其它专注个人用户的厂商靠什么活？这个问题在烧完投资人的钱前要想清楚，不然就会死的很惨了。

安全软件，作为一个可以一直常驻的软件，可以有千万活跃的软件，怎么去赚钱？是变成QQ那样风光还是迅雷那样尴尬。你可以选择去推广告，去赚流量，变身流氓软件也是办法；你也可以选择制定安全的标准，做一个开放的安全平台，为中小安全公司的发展助力。如果你相信'助人者助己'，本文对你就有点作用。

你可以像facebook，twitter开放自己的API，

http://api.cloud_security.tt.com/file/need_upload/md5/0a0ce54dee6659e14024197f4f574960.xml/?u=uuid&s=checkcrc&c=channel

http://api.cloud_security.tt.com/file/check_safe/fs/0,0,0,0,0,0,0,0,3,2,0,0,0,0,0,0.json/?u=uuid&s=checkcrc&c=channel&md5=0a0ce54dee6659e14024197f4f574960

这样，每一个互联网公司或者个人，只要他们有安全的需求，就可以通过这些开放的API来检测一个文件是否安全，而不是必须安装某个软件才行。通过这个平台，也可以更快更准确的收集到病毒样本，可以尽量的减少误报。同时，你也制定了安全的标准，成为行业的控制者。

MySQL慢查询日志自动分割

2009-12-31T14:35:00.002+08:00

MySQL的慢查询日志是揪出"数据库杀手"的好方法。美中不足的是，当我们解决了一个慢查询以后，通过mysqlsla再次分析慢查询日志，并不知道效果如何，因为默认是不会按照日期分割慢查询日志的。

怎么处理？如果不是经常有慢查询，手工做一下即可。MySQL的官方手册写的很清楚：

For example, if the general and slow query logs are named mysql.log and mysql-slow.log, you can use a series of commands like this:
shell> cd mysql-data-directory shell> mv mysql.log mysql.old shell> mv mysql-slow.log mysql-slow.old shell> mysqladmin flush-logs
At this point, you can make a backup of mysql.old and mysql-slow.log and then remove them from disk.

如果你的数据库慢查询太多，囧，可以考虑自动的方法（就是用Logrotate来替你定时完成上面的几个命令，关键是怎么在执行mysqladmin不用输入数据库密码）,参见这里（很详细）

担心哪一天不能访问了,在这里备份一下:)

If you have the resources (CPU + RAM) available on your server then its can be a great troubleshooting tool if you enable MySQL logging which includes server messages, SQL query logs, and slow query logs. If you do not have the resources I would suggest only enable minimal logging such as only server messages and the slow query log since enabling all queries to be written to a file can become expensive rather quickly. Below I discuss enabling three different types of MySQL logging, adding a MySQL configuration file to logrotate, and configuring root to run mysqladmin commands without having to type the password out each time.

Enable MySQL Logging:

First we are going to enable the various types of MySQL logging. I would keep an eye on the query log just in case it becomes to resource intensive. Below I will display the configuration command to enable each type of logging including creating the file and directory that MySQL will log to.

Modify The my.cnf MySQL Config File: First lets add the statements to the MySQL configuration file which by default is typically /etc/my.cnf. There will probably be a minimal set of configuration items in this file if you have never modified it. Add the below lines which include comments above each one to explain what will be logged.
Configure my.cnf To Log Queries, Errors, Slow Queries:
view plain copy to clipboard print ?
1. # Will log MySQL Errors Including Startup Errors
2. log-error=/var/log/mysql/mysqld.log
3. # Will log MySQL queries, This log will grow quickly
4. log=/var/log/mysql/mysql.log
5. # Will log MySQL queries that take a long time (in this case over 1 second as specified below)
6. log-slow-queries = /var/log/mysql/mysql-slow.log
7. long_query_time = 1
The above configuration lines should go under the main section of MySQL which should be "[mysqld]" at the beginning of the file. The next section doesn't start until "[mysqld_safe]" so as you can see there are typically two sections and they are divided by these headings.
Create MySQL Log Directory: I like to try and split services up in the log directory so I can keep track of things easier so in this case we are going to do the same. In the command list below we will be creating a directory, creating blank files, and then making sure everything has the right permissions and is owned by the proper user which should be the "mysql".
Create MySQL Log Directory & Log Files:
view plain copy to clipboard print ?
1. [root@dev ~]# mkdir /var/log/mysql
2. [root@dev ~]# touch /var/log/mysql/mysql.log
3. [root@dev ~]# touch /var/log/mysql/mysqld.log
4. [root@dev ~]# touch /var/log/mysql/mysql-slow.log
5. [root@dev ~]# chown -R mysql.mysql /var/log/mysql
6. [root@dev ~]# chmod -R 664 /var/log/mysql/
So notice that all of the new files will be owned the mysql user in the mysql group and they will allow reading from all users and writing from the mysql user and members of the mysql group.
Restart MySQL & Verify Logging: Now lets restart MySQL and verify the logging is operational. You can restart MySQL by issuing the below command.
Restart MySQL:
view plain copy to clipboard print ?
1. [root@dev ~]# /etc/init.d/mysqld restart
2. Stopping MySQL: [ OK ]
3. Starting MySQL: [ OK ]
4. [root@dev ~]#
If MySQL fails to restart and this is a live server quickly make a backup of my.cnf, remove the changes,and start MySQL so your downtime is minimal. If you follow the directions above you should be fine but I wanted to mention just in case there were any issues with the restart. Now visit some web pages on your site to generate some of the MySQL queries to the database and then view the log files to verify logging is functional. You can view the log files in real time by using the tail command as displayed below.
View New MySQL Log Files In Real Time With Tail:
view plain copy to clipboard print ?
1. [root@dev mysql]# tail -f mysql.log
2. FROM wp_posts WHERE MONTH(post_date) = '12'
3. AND YEAR(post_date) = '2009'
4. AND post_type = 'post' AND post_status = 'publish'
5. AND post_date < '2009-12-20 12:52:13'
Configure Root User MySQL Access: Now in preparation for the logrotate mysql configuration file you want to add a file to the root users home directory so that user can flush the log files without having to use a username and password every single time. If you attempt to flush the MySQL logs before you add the below configuration file you will receive an error similar to the below.
Error When Running mysqladmin flush-logs Without A Password:
view plain copy to clipboard print ?
1. [root@dev ~]# /usr/bin/mysqladmin flush-logs
2. /usr/bin/mysqladmin: connect to server at 'localhost' failed
3. error: 'Access denied for user 'root'@'localhost' (using password: NO)'
Use your favorite editor such as vi as the root user to create a file by the name of .my.cnf in /root/. Add the contents below to this file but of make sure to modify the username and password in the example below to include a MySQL username and password that has access to run "mysqladmin flush-logs".
New /root/.my.cnf File:
view plain copy to clipboard print ?
1. [mysqladmin]
2. user = root
3. password = changeme
Make sure that you set the proper permissions for the above file once you have created it so that no other users on the server can read the file contents and find out what the MySQL root password is. To set the proper permissions use the below command.
Set Permissions On /root/.my.cnf:
view plain copy to clipboard print ?
1. [root@dev ~]# chmod 600 /root/.my.cnf
Now you can run the "mysqladmin flush-logs" command as the root user without having to enter a username or password and without receiving an error.
Add Logrotate MySQL Configuration File: Now add the below configuration contents to a new file named "mysql" in the "/etc/logrotate.d/" directory.
The mysql Logrotate Configuration File Contents:
view plain copy to clipboard print ?
1. /var/log/mysql/*.log {
2. create 644 mysql mysql
3. notifempty
4. daily
5. rotate 5
6. missingok
7. nocompress
8. postrotate
9. # run if mysqld is running
10. if test -n "`ps acx|grep mysqld`"; then
11. /usr/bin/mysqladmin flush-logs
12. fi
13. endscript
14. }
The basis of the file is that it will rotate any files in the MySQL directory that end with ".log". Once the files are rotated the new files will be generated by the mysql user with permissions of 644. The files will not be rotated by Logrotate unless they have contents. The files will be rotated daily and five copies will be retained. Logrotate is not going to panic if there is a file missing and when all is said and done the root user will run "mysqladmin flush-logs" to flush out the log files so logs will continue to write to the proper files.

You are now able to troubleshoot MySQL, web applications, and many other things much easier. Remember to keep an eye on mysql.log to make sure that the file does grow out of hand. Also be sure to check back on the log files after a couple days just to make sure that logrotate is functioning properly. If you don't have logrotate installed and configured yet you can check out the manpage here on QD.

[招聘]珠海金山招聘python开发工程师

2009-11-25T16:57:00.001+08:00

部门发展的比较快，需要两名靠谱的同学加盟:)

职位要求为：

职位：python开发工程师
部门：金山互联网安全公司安全技术研发中心
工作地点：珠海

职位描述：
你是毒霸后台系统的开发者和维护者，为反病毒提供有力支持

职位要求:
a)基础要求
0.良好的代码风格，较强的代码阅读理解能力和调试能力
1.熟悉Linux系统使用
2.熟练使用一种编程语言
3.对数据敏感
4.有较强的发现问题、分析问题与解决问题的能力
5.善于沟通和表达，有良好的团队合作意识

b)符合以下者优先
0.熟悉memcached,lighttpd,nginx,django,mysql,sqlite,postgresql中的2种以上
1.有Nginx和MySQL调优经验
2.熟悉Python程序设计，了解常用库的使用
3.了解存储系统

有意者直接联系我哈 moonbingbing at gmail.com

安全行业最关键的半年

2009-11-22T11:51:00.002+08:00

一个多月前，360引导用户卸载毒霸的时候，就非常明确的感觉到360要对国内的传统杀软厂商下手了。

当时觉得360需要半年左右的时间，来达到国内杀软第一的位置。现在看来，用不了那么久，不到两个月，就有接近2700w的用户量，比毒霸耕耘十年的市场还大。年前，360就会超过瑞星，成为中国最大的杀软厂商（企业市场还不会有啥变化）。

当360两三年后，上市融资成功，也会成为腾讯、阿里巴巴这样的巨无霸。加上360安全卫士和360安全浏览器，其他安全厂商能喝口汤都不大容易。

瑞星现在还有最大的客户端优势，还有企业市场来赚钱；腾讯还不屑于争夺安全这个不怎么赚钱的市场，但绝对警觉360这个痞子对手；毒霸只能背水一战！

还有不少新兴的安全厂商还在觊觎'安全'这块儿蛋糕。

安全行业最关键的半年已经开始了，爆发吧，小宇宙！

MySQL性能调优简介

2009-11-20T13:45:00.003+08:00

抽空总结了一下。参考了Peter Zaitsev April 22, 2009在Percona Performance Conference上面的演讲文档上面的很多东西，多谢这些大牛们。

MySQL调优

View more presentations from moonbingbing.

休假

2009-07-19T02:55:00.002+08:00

千言万语汇成一句话：休假。

千言万语等休假回来再写

绿坝：丑陋的云监控

2009-06-14T23:52:00.002+08:00

实在不想把“云”和绿坝这样的软件联系起来，但它确实是云的一个实例。

之前的监控是GFW，在你的电脑和网站之前架设一个检查站，监控关键字和过滤网址。随着互联网飞速发展，服务器的压力肯定越来越大，效果也越来越不明显。怎么办？“云”是很好的解决办法。

让计算更靠近数据，让每一个客户端都是服务器的一朵云。绿坝生动的实现了“云”，从此GFW穿着保护儿童，打击色情的外衣，来到客户端，合法的监控你的一举一动：你敲的每一个文字，浏览过的每一个网页，写的每一份文档......感觉就像你洗澡，上厕所还有人通过摄像头实时监控一样。

看着网上大家对绿坝的评价，大都从技术角度分析它有多么脆弱。对于绝大部分用户来讲，这样的技术已经够用，政府也不指望可以通过绿坝监控到所有客户端，还有GFW。所以谈论技术没有任何意义，绿坝的意义完全不在技术！

巨大丑陋的乌云正笼罩在我们头顶。

杀软，你的用户在哪儿？

2009-06-14T16:18:00.000+08:00

本人对产品和市场不熟悉，周末去北师大和电脑城逛了逛，只是根据常识和男人的第六感有感而发。

前言：

我一直坚信一个不关心用户需求，觉得产品，市场和研发没有啥关系的程序员写不出好程序。是的，研发没有必要成为产品和市场方面的专家，但心里要一直有一幅清晰的用户需求（而不是只有bug列表）：我的程序是给千千万万个用户使用的，他们需要的产品是什么样子的，有哪些地方需要改进，用户是哪些人，他们是怎么看待自己程序的。

正常情况下，这个需求画面，应该由产品和市场传导给研发的。更专业的做法，应该由第三方独立的咨询公司来完成产品和市场调查。更常见的情况是大家都没有这个画面，太囧了。

用户调查

北师大：随机找了10个学生，4男6女，全部都有电脑。3个用诺顿，3个瑞星，一个mcafee，一个卡巴，一个毒霸，还有一个没有安装杀软。都安装的有360。

诺顿使用量高出乎我的意料，后来才发现是因为北师大机房使用的就是诺顿。

瑞星都是电脑城装机时候安装的盗版。

mcafee是买品牌机送的。

卡巴是网上下载的破解版。

毒霸是因为家里办宽带送的，后来用手机10块一月续费的。之所以不用盗版和不在taobao买便宜的是因为担心不安全。

由此可以推测：诺顿走的是高端路线，城市包围农村，先抢占利润最大的企业市场，再通过企业市场影响个人用户市场，棋走高招；瑞星牢牢把控传统渠道和电脑城，农村包围城市，以最大化抢占个人市场来影响企业市场；mcafee更多的是OEM；卡巴借助泛滥的破解版本和360的推波助澜，不仅对网上渠道有很好的把控，对传统渠道也在悄悄的蚕食，不可小觑；毒霸借助OEM和手机支付迅速上位，但同时传统渠道丧失殆尽，用户认知度和忠诚度偏低，用户定位不清晰，浮躁冒进；360一定意义上面可以控制杀软的市场份额。

传统渠道

电脑城：外墙杀软的广告都是卡巴和瑞星的。卖杀软的店铺里面最显眼的地方都是卡巴，偶尔可以看到江民，没有瑞星和毒霸的身影。

推测：卡巴对传统渠道非常重视；瑞星比卡巴更明白潜规则；江民已是明日黄花；毒霸完全放弃传统渠道。

用户在哪儿？

每个杀软在中国都有自己的用户定位：诺顿是企业用户；卡巴是高端个人用户；瑞星是个人用户；mcafee是有钱的个人用户；毒霸是家庭用户。每个不同的用户定位，决定了市场，产品和研发。

细节反映成败

2009-06-14T11:37:00.003+08:00

细节从来都决定不了成败，细节是成败的表征，是冰山浮在水面上最有价值的一角。

当你对一个人，一个公司，一件事情有些踌躇的时候，就来看看细节吧。你不能指望一个约会经常迟到的人会恪守承诺；不能期望失去梦想，为下个季度财报而努力的公司能善待客户和员工；也不能期待一个横幅有错别字的市场宣传能奏效。

把kingsoft拼成kinsoft；www.duba.net写成www.duba.com；3888->03338->03888,到死都拼不对；毒霸变成独霸，还推向客户端去弹泡泡......

我们的技术并不差，那造成差距的根源在哪儿？我觉得是在心态，是对用户，对员工，对梦想的心态！有人觉得这个东西会影响千千万万的用户，我要做到最好吗？有人觉得员工是公司发展的源泉，要善待员工，留住好员工吗？有人还记得当初的梦想并为之奋斗吗？如果没有，就不要看着报表郁闷了，洗洗睡了吧。

怎么算是一个成功的项目？

2009-04-24T22:07:00.002+08:00

成功的项目最明显的特征就是能赚钱或者能省钱，除了钱，我们还有很多评价结果的标准：

人的成长。
团队的成长。
技术探索和积累。

在我看来，如果人和团队在项目中成长起来，即使这个项目最后没有赚钱，这个项目也是成功的。最怕的是，老大们看错了方向，或者头脑一热，就去做项目，这样的项目就是彻头彻尾的失败了。

反之，一个项目就算赚钱了，但是人和团队没有成长起来，这也不能算是成功的项目。

成长，是一个很抽象的名词，很难去量化，有时候就是一种感觉，是一个蓦然回首才能看到的过程。

笑过，哭过，我们都经历过..

2009-04-06T22:40:00.007+08:00

在youku上面看到一个DV(2个多小时)，里面的每个人都能在我大学寝室的兄弟们身上看到影子，觉得很亲切。我的大学过的还算丰富多彩，如果，当然也只能如果，还能重新再上一遍大学，我会让自己胆子更大一些，眼界更开阔一些 :)

运营运维比研发更重要

2009-03-31T21:03:00.006+08:00

‘行百里者半九十’，就句话用来比喻产品的研发和运营运维非常恰当。

研发是大家都非常重视的一环，开发量占整个过程的绝大部分，但是，良好的研发只是开了好头，如果忽视看似简单的产品运营和运维，再好的产品也得不到用户的认同。

有效的运营，可以及时收集用户的问题（将问题在萌芽期都处理掉），反馈给研发，推动，督促并监管问题的快速解决；稳定的运维，可以为用户提供持久可靠的服务，为研发优化，修改程序提供数据支持。

如果没有好的运营和运维，那么这样的情况是意料之中的：

出问题了，但是没有数据去查找原因。
问题的反馈总是从客户的抱怨声中传到研发的。
服务器端连两个九的可用性都不能保证。

五一长假惹谁了？

2009-03-26T22:20:00.003+08:00

广东刚说要放假7天，今天国务院就说全国五一放假3天，禁止擅自调休。公司也赶快发邮件通知来响应国务院，广东的7天假一个字也没有提。

本来想着这次五一出去玩可能不那么挤了，看来是肯定不挤了。

我们还有年假可以休，那些没有年假，连周末休息都是奢望的人们，谁去保障你们的权利？冠冕堂皇的年假制度最终沦为合法剥削劳动者的借口。

休假不是福利，是权利！应该由国家机器来保障。以前五一是有很多弊端，但它至少保障了很多人休假的权利。现在的休假模型当然比五一黄金周好，但却牺牲了弱势劳动者休假的权利。

python tips

2009-03-16T13:04:00.016+08:00

看别人代码的时候，总是会发现很多好玩儿的用法或者不太注意的库，比较零散，就记录在这儿吧。持续更新......

1、用 ...and ... or ... 来替换 if....else...

old:

if flag:
print 'yes'
else:
print 'no'

new:

print flag and 'yes' or 'no'

2、经常被字符串里面很多的%s搞糊涂？还不快试一下Template

old:

message = '%s is better than %s,and %s is worse than %s.so,%s is better than %s'
print message %('a','b','c','b','a','c')

new:

from string import Template
message = Template( '$a is better than $b,and $c is worse than $b.so,$a is better than $c')
print message.substitute(a='a',b='b',c='c')

跳出框框看问题

2009-03-15T00:31:00.003+08:00

今天看Bret Taylor写的FriendFeed使用MySQL的一些经验：How FriendFeed uses MySQL to store schema-less data ，很有感触。

FriendFeed遇到过的问题，我也遇到过苦恼过，因为想不到好的方法，最后不了了之。而FriendFeed并没有不了了之:so we decided to look outside of the realm of RDBMS. 就是这种跳出框框的思维，让FriendFeed找到了一个非常适合自己的解决方案。

现在看来，数据库的设计真的是一门艺术，需要创造性的思维。不要让书本上面所谓的金科玉律拴住我们的思维。

一直被模仿，从未被超越

2009-03-14T10:42:00.004+08:00

为什么模仿者很难超越被模仿者？按说有了前人的探索和经验，模仿者应该更容易成功才对，但是现实中很少有模仿别人的公司做大作强，超过被模仿者的。

原因笼统的说是因为‘知其然，不知其所以然’。在别人身后亦步亦趋，别人跌倒的地方你也不知道躲过去，别人积重难返的包袱你也照着背上......这样是肯定不能超越对方的。每个公司就像每个人一样，都有自己的个性，适合别人的不一定适合自己。

做一个好的模仿者，必须要知己知彼，取其精华，去其糟粕。

大龄文艺女青年之歌

2009-03-01T21:39:00.003+08:00

很有意思的一首歌

词：邵夷贝
曲：邵夷贝
唱：邵夷贝

王小姐三十一岁了
朋友们见到了她
都要问一个问题：
你什么时候打算嫁呀？
可是嫁人这一个问题
又不是她一个人可以决定的
她问她爸爸
她问她妈妈
他们都说你赶紧的
你看你看你看人家那那那那那那那那那
你看你看你看看那那那那

大龄文艺女青年
该嫁一个什么样的人呢
是不是也该找个搞艺术的
这样就比较合适呢
可是搞艺术的男青年
有一部分只爱他的艺术
还有极少部分搞艺术的男青年
搞艺术是为了搞姑娘
搞姑娘又不只搞她一个
嫁给他干什么呢
搞姑娘又不只搞她一个
奶奶奶奶奶奶的

朋友们介绍了好几个
有车子房子和孩子的
他们说你该找个有钱的
让他赞助你搞创作
可是大款都不喜欢她
他们只想娶会做饭的
不会做饭的女青年
只能去当第三者
不会做饭的文艺女青年
只能被他们潜规则
奶奶奶奶奶奶的

这一首歌纯属雷同
如有虚构纯属巧合
请不要自觉对号入座
然后发动群众封杀我
你看你看你看她只会做西红柿炒鸡蛋
你看你看还要就着方便面
那是非常好吃的
mia mia mia mia mia mia mia
那是非常的好吃的
mia mia mia mia mia mia mia

MySQL备份数据的几种方法

2009-02-25T21:34:00.005+08:00

部门一个大牛曾经说过：‘运营就是备份’。对于数据库的备份问题，很多时候是出事儿以后，大家才能认识到有多严重。。。数据文件不是放到盘柜就安全的，如果MySQL崩溃了，如果盘柜损坏了，如果有人误操作了，如果地震了......

备份分为完全备份和增量备份。

完全备份是备份所有的数据库文件或者将数据库全部dump出来。前者适合比较大的数据库。
增量备份是定期备份二进制日志，备份前使用 flush logs 刷新日志。

备份的时候如果不影响主库的运行，就叫做热备；如果flush table with read lock或者关闭数据库，就是冷备。

可以选择和主库实时同步，也可以选择延时同步。各有适合的场景。

如果已经有slave，那么再建另一个slave的时候，就没有必要从主库拷贝数据库文件了。只要暂停slave的服务，拷贝完文件后，修改my.cnf里面的server-id，以及在主库增加新增slave的replicuser权限，就可以了。

LVM的快照功能可以快速复制数据库文件。参见‘使用LVM快速建立数据库的快照’

有前途的网址认证

2009-02-23T20:27:00.006+08:00

伴随着‘云安全’，文件认证火了一把。而网站/网址的安全认证大家也在暗自较劲。这个比文件的认证对用户的影响更为广泛。国外做的比较好的有mcafee和web of trust（MySQL的创始人最近加入）；瑞星的卡卡文件诊所有对网址的认证，不过功能太弱；知道创宇也提供网站认证的服务，只是不能在网上查询，必须安装客户端软件，可以先去看一下他们的blog，有每天挂马网站的简报。

木马、挂马网站、下载器、钓鱼网站，现在这些因特网最大的威胁将随着网址认证的推广逐渐失去生存的土壤。

如果一个搜索引擎（比如百度）有了网址认证，那么完全可以按照这个网站的安全级别（是否有漏洞，SQL注入，挂马，低俗等）来排名。搜索结果会提示这个网站可能存在的威胁（和google一样）。如果你想提高排名，需要花钱来得知你的网站有哪些漏洞（这个就是google没有做的）。就这样做就能趋‘竞价排名’的利，而避其害了。

希捷的SAS硬盘也有问题？

2009-02-09T13:45:00.004+08:00

今天早上发现一台联想R525报警，RAID10的一块硬盘offline。该服务器没有搬动过，offline的硬盘可以rebuild成功。

硬盘型号是ST3146855SS，146G。

以后绕着希捷走

ps：下午这块硬盘又报unconf bad，只能通知联想换硬盘。还好刚开始用，没有什么重要的数据和应用。

用master-slave实现mysql延时备份

2009-02-04T19:38:00.008+08:00

master-slave不仅可以实现mysql的实时备份，也可以实现延时备份，而且这样实现的备份很灵活。

使用非常著名的maatkit工具集里面的mk-slave-delay，可以让salve落后master指定的时间。用法很简单，自己看文档。

延时备份为什么是必要的？

binlog里面记录的都是有写操作的sql语句。

如果你delete了一条几个月前insert的记录，那么你要先找到那条insert的sql语句；如果批量delete或者drop了一张表，那就够你痛苦的了。当然，找回数据的前提是：binlog完整。如果drop了一张表，那么从create talbe开始，所有执行过的写操作全部重演一次。对于写频繁的表，这是不可忍受的。

延时备份可以让你恢复到一段时间之前，然后你再用日志恢复到那条语句前就可以了。

［重要］希捷硬盘缺陷

2009-01-19T22:05:00.005+08:00

参见新闻：
http://www.cnbeta.com/articles/75219.htm
http://www.it007.com/A/2009-1/Art_27968.html

最近其7200.11系列容量为1TB的硬盘又出现了新的问题。出现此问题的硬盘产地大部分为泰国，原因疑为固件缺陷所致。在故障出现时，硬盘无法自行引导系统，甚至无法读取或写入任何数据。而硬盘上保存的数据甚至可能会全部丢失，如果这些数据非常重要，用户或许只能寄希望于数据恢复公司把它们从故障的硬盘中恢复出来。

没有什么比随时可能丢失数据或者系统莫名其妙蓝屏死机更让SA头痛的了。而希捷全都做到了。有缺陷的硬盘基本涵盖了希捷的主要产品，以后谁还敢用它的硬盘？服务器什么最贵？不是硬件，而是数据！伟大的希捷做到了，不管你做RAID几，它都会在一夜之间让你写辞职报告，卷铺盖走人。

贵的不一定好，但是便宜肯定没有好货，而且便宜的东西机会成本非常的高，一点儿都不划算！

现在明白为啥重要的数据用磁带机备份了。

当当网＝上当

2009-01-12T22:32:00.007+08:00

新年的第一篇博客，本来不想写这个比较愤青的标题。只是如鲠在喉，不吐不快。

去年12月30号的时候帮妹妹买了一本书，因为那个大学比较偏僻，不能选择货到付款。谁知道一直到今天，状态还是‘正在配货’。真正让人恼火的不是时间太长，而是当当根本不重视客户的感受，根本就不积极去解决问题。

打电话给当当，只听到当当在把责任推卸给整理库房，承诺马上处理，但一直没有回应；发邮件，一直没有人理。

大家都是人，都会犯错，这个没有问题。但是，不愿面对问题，不敢承担责任，不能兑现承诺，当当，这像是一个能成功的企业做的吗？这样的企业，不值得给他留一点儿面子和退路。

－－－－－－－－－－－－－－－－－－－－－－－－

如果只是在这里愤青一把，这个博客就没有含量了......从这里面能吸取什么教训呢？我看有以下几点：

主动收集用户的牢骚。美国一家航空公司，一个客户在twitter上面发出一些疑问，很快就收到该公司的邮件回复。有抱怨和投诉的客户，是这个公司的一笔财富。那些整天想着怎么去删除负面信息的公司，是活不长久的。

要有及时有效的反馈。反馈必须要及时，及时表示对人的尊重，没有人有那么多时间配你玩儿。反馈必须要有效，无效的反馈，比如当当客服统一口径的‘库房问题’，谈不到用户真正关心的问题，这种反馈让人反感。

要有应急预案。今天当当出了这么大的事故，别光看笑话，生闷气，你知道明天类似的事情不会发生在你身上吗？是要事先做好准备，还是到时候手忙脚乱？你自己选择。

敢于承担责任。出了问题了，怎么办？怎么向用户解释？你有很多选择，但是推卸责任到其他人身上，不敢说‘这是我的错，对不起’，绝对不是明智的选择。如果你觉得欺骗用户很高明，那么，我确定肯定以及一定，你下次还会犯同样的错。

看看金山，这几点也没有做好。

什么时候该增加MySQL数据库的内存？

2008-12-23T13:54:00.007+08:00

除了优化好数据库配置文件外，更换/增加MySQL数据库服务器的硬件，是提高数据库性能最直接有效的方法。

这里先从最便宜的内存入手。（服务器内存和硬盘价格一般是台式机的5倍左右）

最便捷的方法是使用mysqlreport，来持续关注报告里面‘Key’和‘InnoDB Buffer Pool’这两个部分。如果你的my.cnf参数设置正确，但是Read hit一直低于99%，那么就要考虑增加内存了。

那么Read hit是怎么计算出来的呢？为什么要持续关注？在MySQL的命令行下：

mysql> show status like 'key_read%';
+-------------------+------------+
| Variable_name | Value |
+-------------------+------------+
| Key_read_requests | 3041374401 |
| Key_reads | 60959876 |
+-------------------+------------+
2 rows in set (0.02 sec)

key_efficiency(Read hit) = 1 - (Key_reads / Key_read_requests) = 97.995647100207184%

mysql> show status like 'Innodb_buffer_pool_read%';
+-----------------------------------+------------+
| Variable_name | Value |
+-----------------------------------+------------+
| Innodb_buffer_pool_read_ahead_rnd | 1660545 |
| Innodb_buffer_pool_read_ahead_seq | 576767 |
| Innodb_buffer_pool_read_requests | 2080081461 |
| Innodb_buffer_pool_reads | 292415839 |
+-----------------------------------+------------+
4 rows in set (0.02 sec)

key_efficiency（Read hit）= 1 - (Innodb_buffer_pool_reads / Innodb_buffer_pool_read_requests) = 85.942096764834353%

从文档里面找出这几个参数的意义：

Key_read_requests:从缓存读键的数据块的请求数。

Key_reads:从硬盘读取键的数据块的次数

Innodb_buffer_pool_read_ahead_rnd:InnoDB初始化的“随机”read-aheads数。当查询以随机顺序扫描表的一大部分时发生。

Innodb_buffer_pool_read_ahead_seq:InnoDB初始化的顺序read-aheads数。当InnoDB执行顺序全表扫描时发生。

Innodb_buffer_pool_read_requests:InnoDB已经完成的逻辑读请求数。

Innodb_buffer_pool_reads:不能满足InnoDB必须单页读取的缓冲池中的逻辑读数量。

这几个都是时刻在变化的，一两次的查询并不能暴露问题。

人人为我，我为人人

2008-12-21T15:44:00.004+08:00

开源软件为什么在中国走的这么艰辛？我觉得这个和BT，电驴在中国走下坡路的原因是一样的：可以人人为我，不能我为人人。

国内用到开源代码的软件太多了，可是大家用的都很‘低调’：怕别人知道自己用了开源代码，改了bug怕别人知道，有了bug又埋怨开源的质量。

中国大陆忽视知识产权，不仅仅表现在盗版横行，也表现在软件行业中对开源代码的‘单向’使用和篡改版权。

只有‘人人为我，我为人人’，中国的软件才能真正拥抱开源，才能让世界了解中国软件。这个不仅仅适用于软件，其他的都是这个道理。

2007年泛珠三角大学生计算机作品大赛之黄果树瀑布

2008-12-17T18:43:00.005+08:00

今天梁老师在论坛上面把一年前去贵州的照片贴了出来，还有一篇很有文采的游记。可以去这里看详情

这里贴几张图吧，不舞文弄墨了。

MySQL海量数据优化

2008-12-07T16:50:00.007+08:00

经常见到有人对MySQL处理海量数据（几百万,几千万的数据就不要往海量上面扯了）的能力持怀疑的态度，根据我的经验，MySQL处理单表亿级数据没有任何问题。

数据库最重要的是安全稳定，速度其次。在做任何优化之前，你都必须做好最坏的打算，一定要有备份和应急方案！

要有一个稳定安全的数据库，你必须：

至少要有一个热备

做合适的RAID。RAID0＋1，RAID5或者RAID6

如果可以，最好：

使用xfs而不是ext3。哪天reboot后，你发现磁盘检查要半天，还不能停止，哭都来不及

将数据库数据放入盘柜。更安全，访问更快

现在切入正题，开始优化：

使用64位系统。这是老生常谈了，只要谈优化就少不了这个。不仅MySQL的性能有提升，内存也能使用超过4G。

选择合适的引擎。一般来讲，innodb适合写频繁的表，myisam适合读频繁的表。

建立正确的索引。推荐这篇文章。虽然比较老了，但很经典。

优化my.cnf里面的参数。主要关心和buffer有关的参数，innodb_buffer_pool_size之类的

使用memcache。可以把访问频繁，不经常改动的小表放入memcache；程序对数据库的读操作之前最好访问一下memcache。

打开slow_query_log选项。解决出现的慢查询语句。

优化sql语句。

使用SAS而不是SATA。数据库对硬盘要求很高，很多时候，换个快的硬盘就能有立竿见影的效果。

优化不可能一蹴而就，它是一个长期持续的过程，比如一些参数要在长期的运行中观察测试才能得到一个最优的值。

ps:这篇文章不要错过