Pipy 进化：从可编程代理到应用引擎

网络功能变得越来越复杂，编写和维护的难度提升；新的基于 Pipy 的应用中，Pipy 角色从数据平面变成控制面，需要执行更多复杂非网络的逻辑；从长远来看，Pipy 将更像是一个常见的类似 shell/bash 的系统脚本工具。

以上这些对 Pipy 的编程语法带来巨大的挑战，在最新的版本中我们升级了 Pipy 的语法，使其完成从可编程代理到应用引擎的蜕变，虽然仅有一词之差。

今天这篇就为大家介绍 Pipy 编程有哪些变化。在开始介绍最新设计之前，让我们先看下原来的设计。

设计

在过去的设计中，我们是在网络框架（Configuration API）编程中执行 PipyJS 代码；在最新的设计中，我们是在 PipyJS 代码中使用网络框架。

主体的互换，带来的影响是在使用 PipyJS 做网络编程时灵活性进一步提升，对开发者更加友好，提高开发效率。

让我们来看下网络框架，也就是 Configuration API。

旧设计：配置 API

与传统的 Nginx 一样， Pipy 代理同样需要配置，不同的是 Pipy 使用编程的方式来操作配置（Configuration）。Pipy 提供了一系列的配置 API，而代理编程的过程实际上就是使用 PipyJS 编码操作配置的过程。

写一个最最简单的 Pjs 脚本。

pipy()

pipy() 是每个 PipyJS 脚本都要调用的 API。

在这个脚本中，pipy() 创建了一个空的配置。然后，稍微复杂一点，我们写一个 echo 服务。

# main.js
pipy()
	.listen(8080)
	.serveHTTP(msg => new Message(msg.body))

将脚本保存到 main.js 中，然后执行命令 pipy main.js 就启动了一个 echo 服务。

curl -s http://localhost:8080 -d 'Hello, Pipy!'
Hello, Pipy!

在这个 echo 服务的脚本中，用到了两个 API：listen() 和 serveHTTP()，分别创建了一个 端口 PipelineLayout 并为其添加了 serveHTTP 过滤器。

pipy() 创建了一个 Configuration 对象，调用 Pipeline 相关的 API 时会创建一个 PipelineLayout 对象，然后再调用 Filter 相关的 API 将 Filter 添加到 PipelineLayout 对象上；直到再次调用另一个 Pipeline 的 API。不管是 Pipeline API 还是 Filter API，都是 Configuration 提供的，因此我们称其为 Configuration API。

在脚本中的 msg => new Message(msg.body) 是一个使用箭头操作符 => 定义的函数，这就是 PipyJS 脚本。

如下面这种，类似在网络框架中执行 PipyJS 脚本，就是我们曾经使用的编程方式。

pipy()
	.pipeline_api()
		.filter_api(script)
		.filter_api(script)
	.pipeline_api()
		.filter_api(script)

新设计：Pipeline API

我们用最新的语法来重写上面的 echo 服务。

# main.js
var echo = pipeline($ => $
  .serveHTTP(msg => new Message(msg.body))
)

pipy.listen(8080, echo)

上面的脚本中，我们调用 Pipeline API 创建了一个管道模板。

管道模板（PipelineTemplate），曾经的管道布局 PipelineLayout。它定义了管道的样子，Pipy 只有在运行中处理数据时才会创建管道（Pipeline）。但为了简洁，在编程的时候我们也用 “管道” 来代指 “管道模板”。可以理解静态的管道，就是管道模板。

让我们继续，脚本创建管道时同样描述了它的样子：包含了过滤器 serveHTTP 以及回调函数。

创建的管道被赋值给了变量 echo，并在另一个监听器管道中，直接引用该变量组合两个管道。

由此看来，新的语法更加得接近 JS 后端开发习惯，而 Pipeline API 就是引用的网络编程框架。

script
pipeline_api
script
pipeline_api
script

语法提升

语法提升不得不说是本次升级的另一个重要方面，大大地提升了开发效率。

声明变量

变量的声明曾是饱受诟病的一个点，原来的 PipyJS 语法中不支持函数变量的声明，都是通过自执行的匿名函数来实现的。比如：

((
  config = '',
  index = 0,
  
) => pipy()
  .listen(8080)
  .serveHTTP(
    ((msg, path) => (
      path = msg.head.path,
      new Message(msg.body)
    ))()
  )
)()

升级之后，变量的定义就简单命令很多。

var config = ''
var index = 0

pipy.listen(8080, $=>$
  .serveHTTP(function(msg){
    var path = msg.head.path
    return new Message(msg.body)
  })  
)

Fiber 变量

这次升级还引入了 Fiber，用来替换之前的 上下文（Context）。原来创建上下文变量要通过下面的方式：

pipy({
	_var1: undefined,
	_var2: 0,
})

引入 Fiber 之后，我们可以通过关键词 var 以及 $ 开头的变量名来定义了。

var $var1
var $var2 = 0

我们可以通过一段简单的代码来展示新引入的 Fiber 变量。

var $i = 0

function step() {
  console.log($i)

  new Timeout(1).wait().then(
    function () {
      if (++$i < 5) step()
    }
  )
}

pipy.fork(step)
pipy.fork(step)

执行这段脚本，可以看到如下结果。两次 fork 执行使用的是变量 $1 的副本，这点类似 Unix 的 fork。

2024-02-29 13:43:08.090 [INF] [worker] Thread 0 started
2024-02-29 13:43:09.088 [INF] 1
2024-02-29 13:43:09.088 [INF] 1
2024-02-29 13:43:10.088 [INF] 2
2024-02-29 13:43:10.090 [INF] 2
2024-02-29 13:43:11.090 [INF] 3
2024-02-29 13:43:11.090 [INF] 3
2024-02-29 13:43:12.091 [INF] 4
2024-02-29 13:43:12.091 [INF] 4
2024-02-29 13:43:18.097 [INF] [worker] Thread 0 done
2024-02-29 13:43:18.097 [INF] [worker] Thread 0 ended

分支语法

原来的 PipyJS 语法中还没有支持分支语法，如 if、else、switch，当需要条件分支操作时都要通过过滤器 branch() 实现。

pipy({
  _condition: undefined,
})

  .pipeline()
  .branch(
    () => _condition === 'cond1', 'branch1',
    () => _condition === 'cond2', 'branch2',
    'defaultBranch'
  )

最新的语法中，我们可以使用 if 或者 siwtch。

var $condition

pipeline($ => $
  .pipe(
    function() {
      if ($condition === 'cond1')
        return branch1
      else if ($condition === 'cond2')
        return branch2
      else
        return defaultBranch

      // switch ($condition) {
      //   case 'cond1':
      //     return branch1
      //   case 'cond2':
      //     return branch2
      //   default:
      //     return defaultBranch
      // }
    }
  )
)

模块化

PipyJS 模块化是另一个特色，通过将 PipyJS 脚本分解到多个文件中成为独立的模块，每个模块中都包含了相关功能的必要代码。通过模块化来提高代码的可维护性、增强代码的可复用性、提高软件的可扩展性（需要新增功能时，添加新的模块即可）。

这里不再赘述原来的模块化，有兴趣的可以看 这里。

在新的设计中，我们同样对模块进行了提升。让我们将上面的 ehco 服务脚本进行分解：echo.js 和 main.js。

# echo.js
export default pipeline($ => $
  .serveHTTP(msg => new Message(msg.body))
)

# main.js
import echo from './echo.js'

pipy.listen(8080, echo)

在 echo 模块中，我们使用 export default 关键字对模板进行导出；在 main 模块中，我们通过 import 关键字引入模块。

当需要引用多个模块时，可以通过多个 import，或者下面这种方式。

var modes = ['m1.js', 'm2.js', 'm3.js' ].map( m => pipy.import(m).default )

pipy.listen(8080, ($ => $
  .pipe(modes)
))