但是, Fn并不受欢迎, 因为没有人经常需要, 没有人天天不停地打开和关闭键盘灯, 即使好几年下来有一天遇到了, 先开灯或者在进入黑暗之前打开键盘灯也很正常.

相反, 人们怀念CTRL, 因为人们每天要把手指放在CTRL上面上千遍:

CTRL + C: 复制
CTRL + V: 粘贴
CTRL + S: 保存
CTRL + A: 全选
CTRL + X: 剪切
CTRL + W: 关闭窗口
CTRL + T: 打开浏览器标签
CTRL + 空格: 切换输入法

对比Fn, Fn用不了一两回. 因为那些自以为是很内裤的功能, 其实都是和硬件有关, 根本就不常用到. 比如谁会没事按Fn让自己的键盘灯一亮一灭的, 或者没完没了地调整屏幕亮度和音量, 他有病啊!

大部分的电脑厂商都明白了这个道理, 绝情地把Fn赶走了, 重新迎回CTRL. 但是, 有一个叫IBM的巨人和它的买主还是坚持迂腐, 感情上不愿意把CTRL接回来, 最终决定帮人在BIOS里偷偷给Fn和CTRL换了衣服.

Fn垂头丧气, 成了不受欢迎的失败产品. 现在, 它在寻找一个最不起眼的角落, 想静地躺在那里, 不要像以前那么招摇.

Related posts:

1. screen 命令使用
2. Linux不是Windows
3. 关系数据库应用设计基础
4. 一对多关系的不稳定性
5. 一种有趣的编程模型

现在, 把每一项的概率用一个正整数(概率值)来表示, 不使用百分率, 整数的总和不一定等于100, 可以是任意大小,

实际概率 = 概率值/总和 * 100%

概率选取的算法如下:

• 依次(顺序可随机)将各项按概率值从原点开始放在一维坐标上首尾相连, 这样, 每一项对应一个取值区间
• 在总区间范围内随机选取一个点, 落在哪一项对应的区间就选中哪一项

用伪码表示:

total_p = sum(p1 + p2 + p3 + ...)
rand = random(1, total_p) // [1, total_p]
foreach(items as item){
    rand -= item.p
    if(rand <= 0){
        // 选中了
    }
}

Related posts:

1. 生产者消费者模型中生产者的速度快于消费者时所产生的问题及其解决方法讨论
2. PHP中使用foreach和引用导致程序BUG
3. 写自己的 http_build_query
4. 开发搜索引擎 – PHP中文分词
5. 关系数据库应用设计基础

当今绝大部分的软件系统都用到了关系数据库, 所以, 作为软件开发工程师, 必须掌握关系数据库应用设计能力.

Related posts:

1. 高性能并发Web服务器实现核心内幕
2. 开发爬虫友好的Ajax网站
3. [不会停止]idea’s blog 即将停止了…
4. 朋友在中关村买华硕笔记本被骗
5. 史上最强大的PHP Web面试题(会做就能进百度)

注: 只要你会做了这道题目, 你的能力已经可以进入百度了! 如果别的部门不要你, 请你给我发邮件, 我一定尽我所能强烈推荐你! 如果你不想加入百度, 而别的公司又不要你, 只能说明那家公司瞎眼了.

题目: 见图片, 该图是某网页的一个区域的截图, 用于显示商品或者其它信息的分类. 该分类的每一项可以折叠和收起(展开和收缩, 如果有子分类的话). 分类的级数不固定. 现有一个PHP变量:

$cats = array(
    array(
        'id' => 1,
        'name' => '学术和教育',
        'children' => array(
            array(
                'id' => 2,
                'name' => '自然科学',
                'children' => null,
            ),
            // ...
        ),
    ),
    // ...
);

请写一段PHP代码, 将该数组所包含的分类数据生成一段能实现如图片所示功能的HTML/JavaScript代码, 可不考虑CSS样式.

———-

注解: 这道题目考察的范围非常广, 包括PHP, HTML, JavaScript, CSS, 递归, 只有真正掌握了如上几种全部技能, 才能实现完整的功能, 否则必须依赖分工. 应聘者所能实现的程度越大, 得分就越高.

如果应聘者的应聘职位不包括HTML/JS/CSS, 那么题目可改为: 把上面的PHP数据用缩进换行文本的形式保存到文件, 并读取文件生成一个同样的PHP数组.(自定义格式的序列化和反序列化)

看到这篇日志的读者, 如果已经做了出来, 并且个人想加入百度, 请在评论中回复URL并说明你的意愿, 我会主动联系你. 或者你可以把程序打包发给我.

———-

• 应届生如何成功应聘百度
• PHP和百度招聘

Related posts:

1. 史上最强大的PHP MySQL操作类
2. 最简单的JavaScript两级联动示例
3. JavaScript+jQuery两栏选择控件
4. 国内外一些计算机学习资源的链接

Heapsort primarily competes with quicksort, another very efficient general purpose nearly-in-place comparison-based sort algorithm.

Quicksort is typically somewhat faster, due to better cache behavior and other factors, but the worst-case running time for quicksort is O(n²), which is unacceptable for large data sets and can be deliberately triggered given enough knowledge of the implementation, creating a security risk. See quicksort for a detailed discussion of this problem, and possible solutions.

Thus, because of the O(n log n) upper bound on heapsort’s running time and constant upper bound on its auxiliary storage, embedded systems with real-time constraints or systems concerned with security often use heapsort.

Heapsort also competes with merge sort, which has the same time bounds, but requires Ω(n) auxiliary space, whereas heapsort requires only a constant amount. Heapsort also typically runs more quickly in practice on machines with small or slow data caches. On the other hand, merge sort has several advantages over heapsort:

• Like quicksort, merge sort on arrays has considerably better data cache performance, often outperforming heapsort on a modern desktop PC, because it accesses the elements in order.
• Merge sort is a stable sort.
• Merge sort parallelizes better; the most trivial way of parallelizing merge sort achieves close to linear speedup, while there is no obvious way to parallelize heapsort at all.
• Merge sort can be easily adapted to operate on linked lists (with O(1) extra space^[7]) and very large lists stored on slow-to-access media such as disk storage or network attached storage. Heapsort relies strongly on random access, and its poor locality of reference makes it very slow on media with long access times. (Note: Heapsort can also be applied to doubly linked lists with only O(1) extra space overhead)

Introsort is an interesting alternative to heapsort that combines quicksort and heapsort to retain advantages of both: worst case speed of heapsort and average speed of quicksort.

Related posts:

1. 一种有趣的编程模型
2. C#环形缓冲
3. 写自己的 http_build_query
4. 艾薇儿Avril Lavigne的照片
5. 请提供Fuck-All选项

但是, 浏览器也是安全问题最多的软件之一. 因其应用广泛, 导致攻击方法层出不穷. 前段时间, QQ客户端的某个版本就遇到了这个问题. 这个版本的QQ使用IE作为聊天记录的界面引擎, 似乎由于疏忽的原因, 没有对聊天信息中的HTML标签进行过滤, 导致用户可以通过在聊天信息中包含JavaScript脚本, 从而在对方机器上执行.

例如:

<script type="text/javascript">alert('hahaha');</script>

用户打开聊天历史记录时, 便会弹出一个窗口, 显示”hahaha”. 还有嵌入iframe的:

<iframe src="http://some" width="100%" height="400"></iframe>

这样, 用户在打开聊天历史记录时, 却看到了一个网页, 而这个网页可能是挂马的.

所以, 使用浏览器为核心的客户端软件, 必须重视安全问题, 要对发给浏览器渲染的所有字符进行过滤. 最好的方法是使用一种模板语言, 简单的如ubb, 而不是直接使用HTML.

Related posts:

1. 强大的纯JS数据图工具-flot
2. [转]一个叫做家的地方
3. 用Javascript生成弹出窗口
4. JavaScript+jQuery两栏选择控件
5. 关系数据库应用设计基础

svn diff url_xxx .(这样操作方式和diff命令一致)

url_xxx 就是那个版本的路径, 点号”.”就是当前目录, 没想到竟然不行! 太弱智的东西了! 真正的用法是:

svn diff –new url_xxx –old .(这样不对, 因为顺序弄反了!)

正确的是

svn diff –old url_xxx –new .

svn 从来就是这么弱智, 比如这一篇文章: 请提供Fuck-All选项

Related posts:

1. 如何为Linux生成和打上patch
2. 告诉我应该选择哪一个Linux发行版
3. CVS笔记
4. 请提供Fuck-All选项
5. 通过 HTTP POST 发送二进制数据

fcgi_spawn_connection() 函数:

fcgi_fd = socket(socket_type, SOCK_STREAM, 0);

if (-1 == connect(fcgi_fd, fcgi_addr, servlen)) {
    close(fcgi_fd);
    fcgi_fd = socket(socket_type, SOCK_STREAM, 0);
    /* create socket */
    bind(fcgi_fd, fcgi_addr, servlen);
    listen(fcgi_fd, 1024);

    switch ((child = fork())) {
    case 0: {
        // child process
        if(fcgi_fd != FCGI_LISTENSOCK_FILENO) {
            close(FCGI_LISTENSOCK_FILENO);
            dup2(fcgi_fd, FCGI_LISTENSOCK_FILENO);
            close(fcgi_fd);
        }
        /* exec the cgi */
        execve(arg.ptr[0], arg.ptr, env.ptr);
        exit(errno);
    }
}

我很奇怪, mod_fastcgi 为什么要监听网络连接? 谁会连接它? 问了同事, 同事说可能是 fastcgi 进程要连接它, 可问题是 fastcgi 进程怎么知道连接什么地方, 更不用说, fastcgi 协议里没有提到要 fastcgi 进程主动连接 Web Server 一说.

再看一遍代码, 我注意到了 dup2() 调用, 会不会是 lighttpd 为 php-cgi 进程创建了一个监听 socket? 于是看了下 PHP fastcgi 的代码, 如下解析命令行参数的一段:

"  -b <address:port>|<port> Bind Path for external FASTCGI Server mode\n"
/* if we're started on command line, check to see if
   we are being started as an 'external' fastcgi
   server by accepting a bindpath parameter. */
case 'b':
...
if (bindpath) {
    fcgi_fd = fcgi_listen(bindpath, 128);
}

也就是说, 如果指定了 -b 选项, php-cgi 就会创建监听进程, 如果没有的话, fcgi_fd 就是默认的 0(标准输入的文件描述符), 也就是 FCGI_LISTENSOCK_FILENO.

所以, lighttpd mod_fastcgi 的逻辑是这样, 如果需要 spawn php-cgi 进程, 它会创建一个监听的 socket, 然后把该 socket dup2 到 标准输入的 fd, 接着 fork 并用 execve() 函数执行 php-cgi 程序, 这样, php-cgi 程序就可以使用该监听 socket 来接受 mod_fastcgi 的网络连接了.

只要知道了这个逻辑, 细节问题不必深究.

Related posts:

1. Linux下编译安装Apache/Lighttpd+PHP+MySQL
2. lighttpd配置HTTPS(SSL)
3. Master-Workers 模式处理高负载
4. Ideawu.P2P API 简介
5. SSH ProxyCommand及其思想

Master-Workers(管理者-工作者)模式是处理这种情况的主要方式, 只要有 IO 等待或者其它耗时的操作, 都交互若干个工作者之一处理, 这样, 后续的请求不会被阻塞, 从而实现高负载.

目录:

• 单进程(单线程)网络服务器的结构
• 多进程工作者模式(Master-Workers)
  • Master-Workers 双向通信(长连接之一)
  • Master-Workers 单向通信(短连接)
  • Master-Workers 双向通信(长连接之二)

下文中有时用”进程”一词同时指代进程和线程, 它们的区别主要考虑的是通信方式.

1. 单进程(单线程)网络服务器的结构

单进程网络服务器使用 IO 多路利用接口 – select(doc)/epoll(doc)/kqueue(doc) 等 – 等待网络连接的信号, 收到读信号后, 接收一个应用层报文(如HTTP请求或者其它自定义的报文), 处理, 然后返回响应. 结构如下:

// 主循环
while(1){
    events = select.wait(timeout=100ms)
    foreach(events as e){
        req = e.sock.recv()
        resp = server.process(req)
        e.sock.send(resp)
    }
}

很明显, 如果 process 方法处理的时间较长的话, 那么并发量就很小了, 因为下一个请求必须等待前一个被处理完毕之后才能处理. 这时候, 只能使用多进程或者多线程, 创建所谓的工作者(Worker)进程.

2. 多进程工作者模式(Master-Workers)

首先有一个 IO 进程(称为 Master), 也就是循环执行 select 的那个进程. 另有若干个工作者进程(称为 worker), 等待 IO 进程把报文给它们. 这也是一种”生产者-消费者”的模型. 具体上, 到底 IO 进程应该把哪一层次的数据交给工作者, 是简单的字节数组, 还是应用层的报文, 不同的应用不同设计. 现在假设传递的是完整的应用层报文, 也就是说, IO 进程负责报文解析, 如果报文的解析只消耗极少的资源, 这是最佳的方式.

2.1 Master-Workers 双向通信(长连接之一)

// 启动 10 个工作者
Workers = start_Workers(num=10)
// 主循环
while(1){
    resps = Workers.wait(Workers_timeout=10ms);
    if(resps.count > 0){
        foreach(resps as resp){
            resps.sock.send(resp)
        }
    }

    events = select.wait(select_timeout=10ms)
    if(events > 0){
        foreach(events as e){
            req = e.sock.recv()
            // 仅仅是委托, 会立即返回. 以后通过 Workers.wait() 获取响应.
            Workers.delegate(req)
        }
    }
}

Workers 的工作模式是:

while(1){
    req = req_queue.pop();
    resp = process(req)
    // 响应被加入到发送队列中
    resp_queue.push(resp)
}

wokers.wait 是等待工作者的处理结果事件(从响应队列中读取响应), 而 select.wait 是等待网络事件. 两者逻辑上相同. Workers 和 select 应该等待多久(即 timeout 的取值是多少)? 如果 Workers_timeout 太大, 那么就会导致 Workers_timeout 时间内即使有新的请求进来, 也无法及时处理, 因为 select.wait 还没被执行到. 相对比, 如果 select_timeout 太大, 那么又会导致 select_timeout 时间内响应无法及时发出, 因为程序阻塞在了 select.wait.

2.2 Master-Workers 单向通信(短连接)

短连接是指一次请求响应后便关闭的连接, 而不是时间长短.

那么, 能不能让 Workers.wait(及其对应的网络 send 操作) 和 select.wait(及其对应的网络 recv 操作) 运行在两个不同的线程里? 答案是可以的. 但是, 把同一个连接用两个线程(一个是 select.wait, 另一个是 Workers.wait)来操作, 有时很难处理多线程问题. 还有一个重要的问题, 如果把网络发送放在工作者线程里, 那么一个连接的网络发送阻塞, 会导致其中一整个线程完全失去效用, 仅仅是因为阻塞. 我们不仅要考虑网络读阻塞, 也要考虑网络写阻塞的问题. 不过, 如果是基于短连接的模式, 是可以这么做的, 如果一个响应不会超过 socket 发送缓冲大小的话, send 永远不会阻塞. 程序的结构改变为:

// 启动 10 个工作者
Workers = start_Workers(num=10)
// 主循环
while(1){
    events = select.wait(select_timeout=10ms)
    if(events > 0){
        foreach(events as e){
            req = e.sock.recv()
            // 仅仅是委托, 会立即返回. 不关心响应.
            Workers.delegate(req)
        }
    }
}

Workers 的工作模式是:

while(1){
    req = req_queue.pop();
    resp = process(req)
    // 响应这里发送给客户端
    resp.send()
    resp.close()
}

对于短连接, 这种工作模式非常好. 因为 resp.send() 和 resp.close() 非常快, 操作系统保证调用它们几乎不会阻塞. 但是, 这种模式无法扩展到多台机器.

2.3 Master-Workers 双向通信(长连接之二)

对于长连接, 是否还有更好的处理方法呢? 有的, 那就是把 Worker 做成可 select 的(Selectable), 比如 Master 和 Worker 通过网络通信, 那么就可以 select 处理结果了. 程序结构如下:

// 启动 10 个工作者
Workers = start_Workers(num=10)
// 主循环
while(1){
    events = select.wait(select_timeout=10ms)
    if(events > 0){
        foreach(events as e){
            if(req.type == USER_REQ){
                req = e.sock.recv()
                // 仅仅是委托, 会立即返回. 会通过 select 得到响应.
                Workers.delegate(req)
            }else if(req.type == WORKER_RESPONSE){
                resp = req;
                resp.sock.send(resp)
            }
        }
    }
}

在主循环中只有一个地方会等待, 无论是网络事件, 还是工作者事件, 都会立即唤醒 select.wait, 使事件得到及时得到响应.

这种方式是得到普遍应用的, 比如 lighttpd 的主循环IO 进程和 fastcgi 的通信就是这种方式. 当 Master 和 Worker 的通信使用的是网络 socket 的话, 可扩展性比 PIPE 更高.

欢迎讨论!

Related posts:

1. 数据传输中的停止等待机制的实现
2. Windows Python select标准输入输出
3. Linux下整合Apache和Tomcat
4. 数据通信与传输协议基础
5. PHP中使用foreach和引用导致程序BUG

首先, TCP 协议是一种可靠的传输协议. 这种可靠性可以从两方面理解: 1. TCP 保证数据的有序性和无差错; 2. TCP 尽最大努力确保数据被接收.

有序和无差错可能比较好理解, 但”最大努力”则和我们一般理解的”可靠”有较大差别. 首先, TCP 尽最大努力传输数据, 一旦发送方无法保证数据传输到接收方, 它将通过断开连接(使连接失效)来声明这一点. 其次, TCP 可以明确地告诉一个数据分段已经被对方接收, 但无法准确的断定未被确认的数据没有被对方接收, 也就是说, 数据可能没有被对方接收, 也能已经被对方接收. 这种对传输失败的不确定性, 显然是对可靠性的一个重大打击. “两军队问题(Two Army Problem)“说明了这一点, 事实上, 我们无法判断一个确认(ACK)是丢失了还是没有发出.

大部分可靠协议使用”带重传的正面确认(PAR, Positive Acknowledgment with Re-Transmission)”机制, TCP 协议也不例外. TCP 的如下特点可以在我们设计可靠传输协议时参考:

1. 连接建立

连接的建立是面向连接的协议所必须的. 连接建立的过程双方可进行某些变量的协商, 如序号. 更高层次的应用层协议还协商版本号, 处理速度等.

2. 分段和序号

分段也即是一般所说的”分包”, 也即消息和报文的概念. 序号是为了保证消息的有序性, 用于乱序重排.

分段方式有3种: 1. 固定长度; 2. 报文自声明长度; 3. 分隔符.

基于 TCP 这样可靠传输的协议而设计的上层协议往往不需要序号机制, 但分段大部分情况都是必须的. 序号也是确认和重传的基础. 基于 TCP 的 HTTP, FTP, SMTP 等协议, 没有序号概念. 这是因为, 底层的 TCP 已经保证了有序和数据不会丢失. 基于 TCP 设计的协议也可能需要序号机制, 使用 TCP 的协议需要序号机制的条件为: 1. 协议不依赖连接, 一次上层的会话可能经历 TCP 的断开和重连; 2. 协议不是停止等待式的”请求-响应”模式.

3. 确认和重传

确认和重传消息报文丢失影响的方法. 确认有立即确认和延时确认. 重传的触发时机不仅仅是超时, TCP 还设计了立即重传机制.

4. 滑动窗口

简单的停止等待机制是一种退化了的滑动窗口. TCP 的最大传输速度是 wnd_size/rtt, 因为 RTT 一般主要受物理条件影响, 所以通过增加窗口大小来提高 TCP 的速度.

发送方至少有 4 个变量: snd_una, snd_nxt, snd_max, snd_wnd.

snd_una: 未被确认的第一个序号. TCP 的 ACK 确认的是已收到的最大序号+1.
snd_nxt: 下一个要进行发送(包括重传)的序号, 如果不是重传, 则与 snd_max 相等.
snd_max: 下一个要进行第一次发送的序号, 即已发送的最大序号+1.
snd_wnd: 窗口大小.

接收方至少有 2 个变量: rcv_nxt, rcv_wnd.

rcv_nxt: 下一个要接收的序号, 也即要发送(或已发送的 ACK).
rcv_wnd: 窗口大小.

5. 更多

拥塞控制, 流量控制, 选择ACK, 序号回绕等等, 都是可以学习的东西.

关于 IM 软件的一些问题

IM 的聊天协议需要面向连接吗? 以腾讯 QQ 为例, 它并没有使用应用层的面向连接机制(即会话机制), 而是发送方确保发送到中转服务器, 中转服务器确保发送到接收方.

腾讯的 QQ 缺少序号机制, 无法保证有序性(可完全避免). 而且缺少完善的应用层的确认和重传机制, 常常出现发送方提示发送失败, 但接收方事实上已经收到了的现象(无法完全避免但可减少出现概率到极小).

我认为, QQ 应该解决消息的无序性问题, 并且完善确认和重传机制. 聊天消息应该实现这些状态: 发送中, 取消中, 发送成功, 未发送.

Related posts:

1. 滑动窗口机制简单理解
2. 使用流水线来实现并发
3. Master-Workers 模式处理高负载
4. TCP/IP 指数增长和线性增长的编程实现
5. 异步, 同步, 连接建立, 连接断开, 通信

Windows 控制面板里的”添加/删除应用程序”应该是较早的利用浏览器来做程序界面的一个程序, 当然, 微软肯定还有更早的程序. 后来的 Google Talk, 又是一个经典的利用浏览器做界面的一个软件.

通过分析, 可以发现 Google Talk(gtalk)的程序使用了 mshtml.dll 动态链接库, 这个库就是 IE 引擎. 而且, gtalk 的界面的一部分就是纯 HTML, 用户可以自己修改并生效.

所以说, 使用浏览器引擎作为软件的界面引擎和桌面软件整个架构的核心, 这种技术已经非常成熟了. 以浏览器引擎为核心, 其实是一种更为纯粹的 MVC, 或者说 C/S 模式. 软件界面和逻辑层的通信主要有如下几种:

1. HTTP 网络通信

这种方式, 不仅嵌入浏览器引擎, 而且还嵌入 Web 服务器(如果不做成单纯的 Web 应用的话). 软件界面这时成为一个重新包装了外壳的浏览器. 例如, 用户点击了”计算”按钮, 程序将向嵌入的 Web 服务器提交一个表单, 并读取服务器的计算结果显示出来.

这种方式并不常用, 应该它直接使用浏览器的 Web 应用没有太大区别. 网络延时会成为问题.

2. 使用浏览器控件的 API

浏览器控件(以 MSHTML 为例)提供了 API, 既可让浏览器中的代码(界面)调用宿主程序的代码(后端逻辑), 也可以反之. 这种接口一般就是一个函数, 比如宿主程序可能这样调用界面脚本中的 js_func 函数:

mshtml.InvokeScript('js_func', args);

而浏览器中的代码可能这样调用宿主程序中的 Add 函数:

window.external.Add(1, 2);

仅仅使用这个 API 还是太原始, 如果要做更复杂的程序, 应该自定义一套界面和逻辑的交互协议.

Related posts:

1. Google Talk 界面开发分析
2. Google Talk Developer Home 中文翻译
3. 使用Gaim连接Gtalk
4. 安装和使用Google Earth – Linux
5. endlessssh – SSH 代理工具

echo "欢迎您, ";
if(level > 5){
	echo "高级用户!";
}else{
	echo "用户!"
}
// ... 大段代码
echo '<a href="#">个人信息</a>';
if(level > 5){
	echo "审核文章!";
}else{
	echo "发表文章!"
}
echo "...";

我们看到, 随着功能的继续, 不断地出现 if-else, 可能是十几个. 虽然在 if-else 之外的代码得到了重用, 也即冗余度降低了, 但是, 充斥各处的判断不是也极大地影响了代码的清晰度吗?

如果我 copy-paste 一份公用代码(不可过于极端地反对复制粘贴), 就可以只使用一个 if-else:

if(level > 5){
	echo "欢迎您, 高级用户!";
	// ... 大段代码
	echo '<a href="#">个人信息</a>';
	echo "审核文章!";
	echo "...";
}else{
	echo "欢迎您, 用户!";
	// ... 大段代码
	echo '<a href="#">个人信息</a>';
	echo "发表文章!";
	echo "...";
}

这样, 优化后全部的代码只有一个分支, 才是符合人思维的逻辑, 虽然代码量扩大了近一倍. 而且, “大段代码”可以封装成函数, 优化后的代码在行数和冗余度上不一定增加.

所以, 不要把冗余度作为代码优化的唯一条件, 更不要把 if-else 作为代码重用的唯一方法!

Related posts:

1. PHP浮点数显示和转成字符串
2. Wordpress分页代码
3. Python logging 标准配置
4. 用PHP去除重复图片文件
5. Shell循环

1. Tunneling SSH over REAL HTTP(完善中)

让 SSH 工作在 HTTP 协议上, 从而穿越防火墙.

2. 持续的会话

即使 TCP 网络连接断开(这时, SSH 会话会失效), SSH 会话仍然保持, 直到网络重连后, 会话继续.

项目地址: http://code.google.com/p/endlessssh/

补充:

谢谢评论中 Zealot 朋友的推荐.

大概看了下类似的一个 GNU 项目 httptunnel(http://www.nocrew.org/software/httptunnel.html). 这个项目所使用的交互过程更像是 HTTP 交互, 在一个 HTTP 报文中包含自己的多个报文. httptunnel 没有确认机制, 也没有会话保持机制. 不过, httptunnel 可以值得借鉴.

Related posts:

1. Google Talk Developer Home 中文翻译
2. 开发爬虫友好的Ajax网站
3. 强大的纯JS数据图工具-flot
4. MySQL 查询使用 Group By 的注意点
5. Google Talk 界面开发分析

TCP 会话依赖于 IP 和端口, 也就是说, 一旦双方的任意一方的 IP 和端口发生了改变, TCP 连接就失效了. 另外, 虽然 TCP 有重传机制, 但重传失效的次数和时限用户转难控制. 为解决这两个问题, 需要实现一种不依赖于 IP/Port, 适应极其恶劣(超过 TCP 的容忍范围)的网络环境的连接协议, 称为 endless_tcp.

为了避免实现”另一个 TCP”, 这个协议基于 TCP 协议, 主要的特点是隧道和会话恢复机制.

假设有这样的一个不稳定网络:

     |               |
Node | ~~ network ~~ | Node
     |               |

两个节点之间通过 TCP 进行连接, 但因为网络状况极差, 所以 TCP 连接经常断开, 应用程序频繁显示”Connection reset by peer”. 如果应用程序的会话依赖于一条持续的 TCP 连接, 那么这个程序的使用就非常糟糕了. 我们在使用 SSH 的时候就常遇到这个问题, 当我们的电脑从有线网络切换到无线网络, 或者从某个无线网络区域移动到了另一个无线网络区域, SSH 会话都会失效, 必须重连.

解决这个问题的一种考虑是使用一种不会话不依赖于连接的协议, 如 HTTP. 对于 HTTP, 当你的电脑从办公室移动到家里时, 你在网络的登录会话还是有效的. 对于 SSH, 改变协议不太现实. 解决的思路是实现更健壮的连接协议. 如何在 TCP 不稳定的网络中建立起稳定的连接, 而这种连接又是基于 TCP 的呢? 首先, 我们使用隧道技术, 把 SSH 的会话数据转到隧道中. 系统被改成下面的结构:

     |               |
Node |               | Node
 ||  |               |  ||
Proxy| ~~ tunnel ~~  |Proxy
     |               |

虽然网络不稳定, 但 Node 和 Proxy 之间的网络是非常稳定的, 比如两者在同一台机器上. Proxy 之间的会话不依赖连接, 所以可以基于 TCP 实现更健壮的连接.

对于 SSH, ProxyCommand 选项提供了非常简便的 SSH 客户端与隧道的接口, 使用该选项, SSH 客户端使用标准输入输出, 而不是 socket. 一个 Python 语言开发的程序, 证明了这种思路的正确性和可行性.

如果隧道使用了 HTTP 协议, 则可以穿越防火墙. 反过来, 建立于其上的 SSH, 也可以被用来进行加密通信.

Related posts:

1. SSH ProxyCommand及其思想
2. PHP解析HTML和loadHTML乱码
3. C# 版的 SimpleXML
4. Chrome浏览器必装的插件
5. endlessssh – SSH 代理工具

SSH 会话基于一个 TCP 连接. 如果我们把连接的两个端口各自的出口(也即入口)进行截获, 就可以用其它的信道来传输. 而且 SSH 仍然认为它用的是和另一端连接一条 TCP 连接.

ProxyCommand 指定一个命令(或程序, 称为 Proxy), SSH 客户端将通过标准输入输出和这个命令启动后的进程进行正常的 SSH 通信, 而 Proxy 连接着 SSH 服务器(一般是一个 Server Proxy, 再由该 Server Proxy 连接服务器). Proxy 和 Server Proxy 之间组成了一条隧道. 如果两者之间用 HTTP 协议进行通信, 则整个系统便称为”tunneling SSH over HTTP”, 当然也可以使用 UDP, TCP, IP 以及其它任意的可行的协议.

SSH ProxyCommand 相对于 SOCKS, HTTP 或者其它的 Proxy 技术, 更简单. 因为它工作在进程间的文件 IO 通信, 用任何支持 socket 的编程语言, 都能轻易地编写出一个可用的 Proxy. 复杂度只落在隧道本身. 想一想, 如果没有 ProxyCommand, 你需要改变或侵入操作系统的 TCP 子系统才能实现 SSH 隧道. ProxyCommand 提供了方便应用隧道的接口, 网络程序都应该提供这样的接口, 而不是完全依赖于 socket.

因为一个会话就会启动一个 ProxyCommand 进程, 所以, 只有在会话依赖于连接的协议上才能使用这种技术.

Related posts:

1. endless_tcp – 一种适应极端网络环境的网络软件架构
2. Lighttpd mod_fastcgi源码分析
3. lighttpd配置HTTPS(SSL)
4. Linux下编译安装Apache/Lighttpd+PHP+MySQL
5. Ideawu.P2P API 简介

为此, 我开发了 win_stdio, 让 select 也能对 stdin/stdout 进行操作. 核心思想就是用 socket 作为 stdin/stdout 的代理. 结构示意如下:

stdin -> stdin_sock -> my_stdin
stdout <- stdout_sock <- my_stdout

my_stdin 和 my_stdout 是 socket, 所以它们的 fileno 就可以用于 select 了.

首先一个线程读取 stdin, 写入 stdin_sock:

while True:
	data = os.read(sys.stdin.fileno(), 1024)
	if not data:
		break
	stdin_sock.send(data)

另一个线程读取 stdout_sock, 写入 stdout:

fd = sys.stdout.fileno()
while True:
	data = my_stdout.recv(1024)
	if not data:
		break
	os.write(sys.stdout.fileno(), data)

win_stdio 的一个实际例子如下:

from stdio import stdio
stdio.write('hello world')
data = stdio.read()
print stdio.STDIN_FILENO
print stdio.STDOUT_FILENO

下载: win_stdio.zip

Related posts:

1. 最简单的JavaScript两级联动示例
2. Python logging 标准配置
3. 软件体系结构模式-层
4. 使用Python POST任意的HTTP数据以及使用Cookie
5. PHP的continue 2

PyPy 项目可能会颠覆老学究和初学者的逻辑, 因为 PyPy 用 Python 语言来实现 Python 语言, 就像一只小蟒蛇吞下自己的尾巴. 也许你没见过, 但它确实存在.

你可能会疑惑, 既然已经有了 Python, 那么为什么还用 Python 来实现 Python(PyPy)? 后者到底是什么东西?

其实, 这其中的逻辑并不复杂. 比如 C 语言, C 语言的第一个编译器肯定不是用 C 语言来编写的, 但之后, C 编译器(如 GCC)就没有理由不用 C 来编写了. 所以, 用 Python 语言编写, 并用已存在的 Python 编译器(解释器, 执行环境)来做一个实现 Python 语言并没有什么奇怪.

简单地说, PyPy 是用 Python 语言写了一个工具, 将 Python 代码转成 C, .NET, Java 等语言和平台的代码. PHP 也有类似的项目 – HipHop-PHP, 把 PHP 代码转成 C++ 代码.

为什么要将一种语言转成另一种语言? 首先是目标语言可能在性能(如C语言)和/或跨平台(如 .NET, Java)等方面具有优势. 其次, 在转换的过程, 可以进行代码优化或加入新技术, 比如 PyPy 应用的 Just-in-Time(JIT) 技术, 能让 Python (事实上是转换后的目标代码)的执行速度更快.

PyPy 和许多编译器, 解释器, 翻译器不同, 它不关心 Python 代码的词法分析和语法树. 因为它是用 Python 语言写的, 所以它直接利用 Python 语言的 Code Object. Code Object 是 Python 字节码的表示. 也就是说, PyPy 直接分析 Python 代码所对应的字节码, 这些字节码即不是以字符形式也不是以某种二进制格式保存在文件中, 而在 Python 运行环境中.

越来越多的编程语言被设计成解释型, 但考虑到性能时, 几乎不约而同地想到转换成 C 语言. C 语言已经成为一个标杆, 任何编程语言都可以根据其距离 C 语言的远近来分类.

Related posts:

1. 开始学习 Python
2. 用脚本语言开发网游 – C整合Python
3. Windows Python select标准输入输出
4. MySQL 查询使用 Group By 的注意点
5. 小巧且强大的集成开发环境(IDE) – Code::Blocks

以博客程序作为例子, 想当然地, 认为博客作者只能是一个人, 所以用户和博客文章的关系是一对多的. 但是, 如果不把博客当为个人的日记本来使用, 把博客当做文章发布平台, 这时, 这个模型就不能使用了, 因为文章的作者是可以有多人的.

这只是其中一个例子, 你可能认为有真正的文章发布平台, 不应该把博客程序当做文章发布系统. 想想, 人们会本能地认为一个部门只能属于一个公司, 一个小组只能属于一个部门, 但是, 多个公司合办的交流部门呢? 两个部门合作的小组呢? 这种例子数不胜数.

根据我的经验, 一旦有人设计对象关系模型(如数据库设计)时使用出了一对多关系模型, 我们应该像看到了想抢我们饭碗的人一样警惕起来: 真的是一对多关系吗? 就跟我们问一个从天而降的不明类人生物: 你是地球人吗?

Related posts:

1. 概率选取的实现
2. 主要排序算法的比较(精炼)
3. 以浏览器引擎为核心的软件架构
4. Mesh: 对象的多对多关系
5. 使用流水线来实现并发

基于行的数据库可以通过一对多关系的表很容易地表示树形结构的对象. 但是, 基于列的数据库, 如何表示呢?

假设有一个对象实例, 它的某个字段是其它类型对象的列表. 这时, 如何用列的实例表示这个对象?

首先, 基于列的数据库, 任何对象的实例都可以用一个id列表, 该id一般设计为整数.

列实例(称为字段)不直接声明自己属于哪一个对象, 通过单独的存储对象和列实例的关系来表示原始对象(raw), 这种对象的每一个字段都是原始数据类型.

如果对象的某个字段是其它对象的列表, 如何表示?

这里使用对象与对象的关系表来存储.

* 对象定义, row<name>
* 列定义, column<name, type>

* 对象表<id>
* 字段表<id, value>
* 对象与字段关系表<oid, fid>
* 对象与对象关系表<oid, oid>

对象查询操作语言:

select column/object
where <condition>

struct row{
	int id;
	char name[256];
};

struct column{
	int id;
	int type;
	char name[256];
};

struct object{
	int id;
	int row_id;
};

struct field{
	int id;
	int col_id;

	struct{
		int len;
		union{
			double number;
			char *bytes;
		};
	}value;
};

struct of_item{
	int oid;
	int fid;
};

struct oo_item{
	int id1;
	int id2;
};

Related posts:

1. JavaScript+jQuery两栏选择控件
2. Windows Python select标准输入输出
3. JavaScript分页控件
4. 最简单的JavaScript两级联动示例
5. Master-Workers 模式处理高负载

——

在数据库设计中, 每一个表都应该有一个字段作为主键. 这个字段一般是自增整数字段, 或者某些数据库支持的自动产生不重复字符串的字段, 也可以是程序自己产生的唯一标识. 总之, 每一个数据库表都应该有一个单一的字段作为主键.

使用单一的字段作为表的主键, 有许多优点. 最重要的一条是可以通过一个原子属性(如整数, 字符串)来标识一行记录. 一旦可以方便地标识一行记录, 那么数据的查询, 更新, 删除也都非常简单.

如果一个表没有主键, 那么必须通过一行记录本身才能标识一行记录. 也就是, 你必须知道一行记录的每一个字段的值, 才能在 SQL 语句中操作这条记录.

数据库表支持联合主键, 也就是使用表的至少2个字段作为主键. 使用联合主键的缺点和不使用主键的缺点有很大的相似性, 因为当联合主键所使用的字段越多, 联合主键的缺点就越来越趋近于不使用主键, 直到表的所有字段作为主键时, 和不使用主键几乎是完全相同的 – 除了前者不能存在重复行,

作为主键的字段一般使用自增整数字段, 因为绝大多数关系型数据库管理系统都支持这种字段类型, 而且速度快, 占用空间少. 一个害怕使用自增整数字段作为主键的理由是自增整数会回绕从而导致重复. 但这种担心是没有必要的. 对于最普通的32位无符号整数, 其最大值是在 Mysql 中是 4294967295(43亿) , 如果数据库表以每秒1条的速度保存记录, 那么一天也只能 86400 条(约10万条)记录, 需要 49710 天(约136年)之后才能发生重复. 幸运的是, 绝大多数系统产生数据的速度比这个假设慢得多了. 如果系统产生数据的速度确实足够快速, 则可以使用 64 位的长整型整数.

如果确实需要联合主键, 则可以使用 UNIQUE 索引来代替. 任何不得不使用联合主键的需求, 都是基于对关系数据库的错误理解而产生的. 并不是要用"单一主键"来覆盖"复合主键"的需求, 而是"在表设计中, 单一主键是必须的, 用联合唯一索引来覆盖’复合主键’的需求".

一个例子:

表1: 使用联合主键(只是作为反面例子出现, 它应该被联合唯一索引代替)

table_a{
    field_a: PK;
    field_b: PK;
    field_…: PK
    field_c;
}

表2: 不使用联合主键

table_b{
    id: PK;
    field_a: UNIQUE;
    field_b: UNIQUE;
    field_…: UNIQUE
    field_c;
}

* 联合主键导致数据操作复杂化

这两种表定义都能反映相同的业务模型. 使用联合主键对保存数据的程序代码影响不大, 情况1通过联合主键保证不会产生重复数据, 但情况2通过联合唯一索引保存不会产生重复数据. 但对查找操作有不良影响, 同时影响到使用了查找功能的更新和删除操作. 考虑查找特定几条记录的情况:

表1: 查找 (field_a, filed_b, …) = [(1, 2, ...), (1, 3, ...), (2, 4, ...), ...] 这几条记录.
表2: 查找 id = [1, 2, 3, ...] 这几条记录.

显然, 表2的描述更简洁, 从而使程序代码和 SQL 语句更简洁. 如果把所有的字段都作为主键, 那么表1就不存在查找特定几条记录的功能了, "因为已经知道, 所以不必再找". 这是一种最极端的联合主键的副作用, 联合主键的字段越多, 就越趋向于这种极端.

* 联合主键不利于表示"关系"

联合主键不利于表示"关系", 是因为它会造成不必要的冗余. 考虑有另外两个表, 需要分别关联 table_a 和 table_b:

table_ac{
    id;
    table_a_field_a;
    table_b_field_b;
    …
}

table_bc{
    id;
    table_b_id;
}

显然, 不使用联合主键可以减少冗余. 如果使用所有字段作为联合主键, 将变成把 table_a 的数据保存两份, 一份在 table_a, 另一份包含在 table_ac. 个人认为, 联合主键是是关系数据库理论一种概念, 在实际中如果使用是"反关系数据库模型"的, 实际使用应该用联合唯一索引替代.

Related posts:

1. 以浏览器为核心的客户端软件的安全问题
2. endlessssh – SSH 代理工具
3. 一种有趣的编程模型
4. 生产者消费者模型中生产者的速度快于消费者时所产生的问题及其解决方法讨论
5. AMD收购ATI 的意义