一 安装redis

1. 下载redis包：wget http://download.redis.io/releases/redis-2.8.9.tar.gz

2. 解压redis包后，进入redis-2.8.9目录中，进行编译

先 make

然后 make install

测试一下 make test

最后运行redis服务端 /usr/local/bin/redis-server (服务端redis-cli)

3. 到此为止，就算安装完成了redis了

Q: 此时报错：Fatal error: Class ‘Redis’ not found in xxx.php on line 9.
A: 因为没有安装php的redis扩展，所有php无法直接操作redis

二 现在是安装php的redis的扩展

1，下载地址： http://pecl.php.net/package/redis

2. 选择需要的版本:

Available ReleasesVersionStateRelease DateDownloads

需要注意两个字段

系统架构： Architecture x86 x86

Zend版本：Zend Extension Build API320151012,TS,VC14 TS VC14

3. 安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#加压文件到当前目录
tar  -zxvf  redis-2.2.8.tgz

#进入解压后的文件目录
cd  redis-2.2.8

#用phpize生成configure
/usr/local/php/bin/phpize 

#编译配置
./configure --with-php-config=/usr/local/php/bin/php-config

#编译
make

#安装
make  install

4，配置php.ini文件，使得php可以支持redis扩展

编辑 /etc/php.ini 添加: extension=redis.so

重启服务；

测试下 php -i|grep redis

1
2

redis
Registered save handlers => files user redis rediscluster redis rediscluster

到此Redis扩展安装完成

文字版

1. fdisk -l //先查询未挂载的硬盘名如：sdb1 等

2. mkfs.ext3 /dev/xvdb(新的盘) // 开始格式化

3. df -h // 查看挂载情况

4. mount /dev/xvdb /home // (/home挂载的地方， 最好是根路径下建一个空的文件夹) 开始挂载

5. vi /etc/fstab // 设置自动开启启动

   格式： /dev/xvdb /home ext3 defaults 0 0 // 硬盘名 需要挂载的位置 格式

6. 卸载挂载点： umount /home/ftp2

另：如果执行fdisk -l 报错，往下看↓

发现有问题：

Disk /dev/sdb doesn’t contain a valid partition table

fdisk /dev/sdb 跟着向导一步步做下去（如果不知道该输入什么，就输入“m”并回车，可以打印出菜单）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Command (m for help): m

Command action

a   toggle a bootable flag

b   edit bsd disklabel

c   toggle the dos compatibility flag

d   delete a partition

l   list known partition types

m   print this menu

n   add a new partition

（后面的菜单省略，太长了）

这里我们要添加一个新的分区，所以输入“n”：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Command (m for help): n

Command action

e   extended

p   primary partition (1-4)

p

Partition number (1-4): 1

First cylinder (1-14098, default 1): （此处直接回车）

Using default value 1

Last cylinder or +size or +sizeM or +sizeK (1-14098, default 14098): （此处直接回车）

Using default value 14098

Command (m for help): p

Disk /dev/sdb: 115.9 GB, 115964116992 bytes

255 heads, 63 sectors/track, 14098 cylinders

Units = cylinders of 16065 * 512 = 8225280 bytes

Device Boot      Start         End      Blocks   Id  System

/dev/sdb1               1       14098   113242153+  83  Linux

现在可以写入分区表了，所以输入“w”：

1
2
3
4
5
6
7

Command (m for help): w

The partition table has been altered!

Calling ioctl() to re-read partition table.

Syncing disks.

现在再fdisk -l，结果正常

– 如果到这里挂载完成，以下内容可不看 –

图文版

查看新硬盘

fdisk -l

新添加的硬盘的编号为/dev/sdb

硬盘分区

• 进入fdisk模式

fdisk /dev/sdb

• 输入n进行分区

• 选择分区类型

这里有两个选项：

p: 主分区 linux上主分区最多能有4个

e: 扩展分区 linux上扩展分区只能有1个，扩展分区创建后不能直接使用，还要在扩展分区上创建逻辑分区。

这里选择的p。

• 选择分区个数

只分1个分区 直接输入1 接下来设置柱面，默认即可

• 写入分区表 输入w，分区结束

• 分区结束后，查看/dev目录

ls -l /dev

可以看到刚刚生成的新分区sdb1

格式化分区

将新分区格式化为ext3文件系统

mkfs -t ext3 /dev/sdb1

最后写入文件系统信息。

此时就可以用新创建的分区了

挂载硬盘

• 创建挂载点

在根目录下创建storage目录

mkdir /storage

• 将/dev/sdb1挂载到/storage下

mount /dev/sdb1 /storage

设置开机启动自动挂载

新创建的分区不能开机自动挂载，每次重启机器都要手动挂载。

设置开机自动挂载需要修改/etc/fstab文件

vi /etc/fstab

在文件的最后增加一行

/dev/sdb1 /storage ext3 defaults 1 2

基础概念

Program Errors

• trapped errors。导致程序终止执行，如除0，Java中数组越界访问
• untrapped errors。 出错后继续执行，但可能出现任意行为。如C里的缓冲区溢出、Jump到错误地址

Forbidden Behaviours

语言设计时，可以定义一组forbidden behaviors. 它必须包括所有untrapped errors, 但可能包含trapped errors.

Well behaved、ill behaved

• well behaved: 如果程序执行不可能出现forbidden behaviors, 则为well behaved。
• ill behaved: 否则为ill behaved…

强、弱类型，静态、动态类型

强、弱类型

• 强类型strongly typed：如果一种语言的所有程序都是well behaved——即不可能出现forbidden behaviors，则该语言为strongly typed。
• 弱类型weakly typed：则为weakly typed。比如C语言的缓冲区溢出，属于trapped errors，即属于forbidden behaviors..故C是弱类型

前面的人也说了，弱类型语言，类型检查更不严格，如偏向于容忍隐式类型转换。譬如说C语言的int可以变成double。 这样的结果是：容易产生forbidden behaviours，所以是弱类型的

动态、静态类型

• 静态类型 statically: 如果在编译时拒绝ill behaved程序，则是statically typed;
• 动态类型dynamiclly: 如果在运行时拒绝ill behaviors, 则是dynamiclly typed。

误区

大家觉得C语言要写int a, int b之类的，Python不用写(可以直接写a, b)，所以C是静态，Python是动态。这么理解是不够准确的。譬如Ocaml是静态类型的，但是也可以不用明确地写出来，所以 Ocaml是静态隐式类型

静态类型可以分为两种：

• 如果类型是语言语法的一部分，在是explicitly typed显式类型；
• 如果类型通过编译时推导，是implicity typed隐式类型, 比如ML和Haskell

示例

弱类型：

1
2
3

> "1"+2

> '12'

强类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

>>> "1"+2

Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: cannot concatenate 'str' and 'int' objects动态类型：

>>> a = 1

>>> type(a)

<type 'int'>

>>> a = "s"

>>> type(a)

<type 'str'>

静态类型：

1
2
3
4
5
6

Prelude> let a = "123" :: Int

<interactive>:2:9:

Couldn't match expected type `Int' with actual type `[Char]'    In the expression: "123" :: Int    In an equation for `a': a = "123" :: Int

这些组件、工具和库描绘了现代PHP的样子：

Slimframework： 一个很好、很酷的小型框架

Symfony：一个由很多优秀、可重用组件构成的重量级框架

Guzzle：可以很简单容易发起HTTP请求的客户端

PHPUnit： 一个测试框架

Behat： 行为驱动的测试框架

PHPCS/CBF：代码规范、美化工具

Faker：生成测试数据的库

Psysh: 充满令人惊讶的交互式控制台

Composer：依赖管理，且有着其他很多有用的特性

Packagist：PHP包仓库

Twig: 模板引擎

单行文本

单行文本只需要将文本行高(line-height)和所在区域高度(height)设为一致即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!--html代码-->
<div id="div1">
    这是单行文本垂直居中
</div>

/*css代码*/
<style>
#div1 {
    width: 300px;
    height: 100px;
    margin: 50px auto;
    border: 1px solid red;
    line-height: 100px; /*设置line-height与父级元素的height相等*/
    text-align: center; /*设置文本水平居中*/
    overflow: hidden; /*防止内容超出容器或者产生自动换行*/
}
</style>

显示结果:

多行文本

多行文本垂直居中分为两种情况，一个是父级元素高度不固定，随着内容变化；另一个是父级元素高度固定。

父级高度不固定的时，高度只能通过内部文本来撑开。这样，我们可以通过设置内填充（padding）的值来使文本看起来垂直居中，只需设置padding-top和padding-bottom的值相等：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<!--html代码-->
<div id="div1">

    这是多行文本垂直居中，

    这是多行文本垂直居中，

    这是多行文本垂直居中，

    这是多行文本垂直居中。
</div>

/*css代码*/
<style>
#div1{
    width: 300px;
    margin: 50px auto;
    border: 1px solid red;
    text-align: center; /*设置文本水平居中*/
    padding: 50px 20px;
}
</style>

显示结果：

父级高度固定的时，设置父级div的display属性：display: table;；然后再添加一个div包含文本内容，设置其display:table-cell;和vertical-align:middle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<div id="outer">

    <div id="middle">

    这是固定高度多行文本垂直居中，

    这是固定高度多行文本垂直居中，

    这是固定高度多行文本垂直居中，

    这是固定高度多行文本垂直居中。

    </div>
</div> 
<style>
#outer{
    width: 400px;
    height: 200px;
    margin: 50px auto;
    border: 1px solid red;
    display: table;
}

#middle{
    display:table-cell;
    vertical-align:middle;
    text-align: center; /*设置文本水平居中*/
    width:100%;
}
</style>

显示结果:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class A {
    private function foo() {
        echo "a";
    }
    public function test() {
        $this->foo();
    }
}
class B extends A {
    public function foo() {
        echo 'b';
    }
}
$b = new B();
$b->test(); // a

当子类继承父类之后，this的指向是动态绑定的，也就是说，当父类的方法被重写之后，调用的就是子类的方法，没有重写，就调用父类的方法。

在本文中，父类的foo方法是私有的，并没有继承给子类，也就没有重写之说，所以，根据前面的定论，没有重写就调用父类中的方法。所以就打印了’a’。

另外还有三种绑定方式，分别是 self parent static。

self是静态绑定，它的指向始终是在编译时所在的那个类。parnet也是静态绑定，它始终指向编译时所在类的父类，而这个父类是声明类时就指定了的，所以指向是明确的。static属于后期静态绑定，或者说是动态绑定或运行时绑定，它的指向与调用者有关。若调用者是所在类的实例，那么它就指向本类；若调用者是所在类子类的实例，它则指向子类。

背景知识

• 大致了解几个基本术语（HTTPS、SSL、TLS）的含义

• 大致了解 HTTP 和 TCP 的关系（尤其是“短连接”VS“长连接”）

• 大致了解加密算法的概念（尤其是“对称加密与非对称加密”的区别）

• 大致了解 CA 证书的用途

HTTP

HTTP 是一个网络协议，是专门用来帮你传输 Web 内容滴。大部分网站都是通过 HTTP 协议来传输 Web 页面、以及 Web 页面上包含的各种东东（图片、CSS 样式、JS 脚本）。

TCP

简单地说，TCP 协议是 HTTP 协议的基石——HTTP 协议需要依靠 TCP 协议来传输数据。

在网络分层模型中，TCP 被称为“传输层协议”，而 HTTP 被称为“应用层协议”。

有很多常见的应用层协议是以 TCP 为基础的，比如“FTP、SMTP、POP、IMAP”等。

TCP 被称为“面向连接”的传输层协议。关于它的具体细节，我就不展开了，你只需知道：传输层主要有两个协议，分别是 TCP 和 UDP。TCP 比 UDP 更可靠。你可以把 TCP 协议想象成某个水管，发送端这头进水，接收端那头就出水。并且 TCP 协议能够确保，先发送的数据先到达（与之相反，UDP 不保证这点）。

SSL/TLS

SSL 是全称 Secure Sockets Layer*（安全套接层）。它是在上世纪90年代中期，由网景公司设计的。（顺便插一句，网景公司不光发明了 SSL，还发明了很多 Web 的基础设施——比如 *CSS 样式表”和 JS 脚本）

为啥要发明 SSL 这个协议捏？因为原先互联网上使用的 HTTP 协议是明文的，存在很多缺点——比如传输内容会被偷窥（嗅探）和篡改。发明 SSL 协议，就是为了解决这些问题。

到了1999年，SSL 因为应用广泛，已经成为互联网上的事实标准。IETF 就在那年把 SSL 标准化。标准化之后的名称改为 TLS（是“Transport Layer Security”的缩写），中文叫做“传输层安全协议”。

很多相关的文章都把这两者并列称呼（SSL/TLS），因为这两者可以视作同一个东西的不同阶段。

HTTPS

通常所说的 HTTPS 协议，说白了就是“HTTP 协议”和“SSL/TLS 协议”的组合。你可以把 HTTPS 大致理解为——“HTTP over SSL”或“HTTP over TLS”（反正 SSL 和 TLS 差不多）。

HTTP 协议如何使用 TCP 连接？

HTTP 对 TCP 连接的使用，分为两种方式：俗称“短连接”和“长连接”（“长连接”又称“持久连接”，洋文叫做“Keep-Alive”或“Persistent Connection”）

假设有一个网页，里面包含好多图片，还包含好多外部的CSS 文件和 JS 文件。在“短连接”的模式下，浏览器会先发起一个 TCP 连接，拿到该网页的 HTML 源代码（拿到 HTML 之后，这个 TCP 连接就关闭了）。然后，浏览器开始分析这个网页的源码，知道这个页面包含很多外部资源（图片、CSS、JS）。然后针对每一个外部资源，再分别发起一个个 TCP 连接，把这些文件获取到本地（同样的，每抓取一个外部资源后，相应的 TCP 就断开）

相反，如果是“长连接”的方式，浏览器也会先发起一个 TCP 连接去抓取页面。但是抓取页面之后，该 TCP 连接并不会立即关闭，而是暂时先保持着（所谓的“Keep-Alive”）。然后浏览器分析 HTML 源码之后，发现有很多外部资源，就用刚才那个 TCP 连接去抓取此页面的外部资源。

在 HTTP 1.0 版本，默认使用的是“短连接”（那时候是 Web 诞生初期，网页相对简单，“短连接”的问题不大）；

到了1995年底开始制定 HTTP 1.1 草案的时候，网页已经开始变得复杂（网页内的图片、脚本越来越多了）。这时候再用短连接的方式，效率太低下了（因为建立 TCP 连接是有“时间成本”和“CPU 成本”滴）。所以，在 HTTP 1.1 中，默认采用的是“Keep-Alive”的方式。

加密和解密

通俗而言，你可以把“加密”和“解密”理解为某种互逆的数学运算。就好比“加法和减法”互为逆运算、“乘法和除法”互为逆运算。

“加密”的过程，就是把“明文”变成“密文”的过程；反之，“解密”的过程，就是把“密文”变为“明文”。在这两个过程中，都需要一个关键的东东——叫做“密钥”——来参与数学运算。

啥是“对称加密”？

所谓的“对称加密技术”，意思就是说：“加密”和“解密”使用相同的密钥。这个比较好理解。就好比你用 7zip 或 WinRAR 创建一个带密码（口令）的加密压缩包。当你下次要把这个压缩文件解开的时候，你需要输入同样的密码。在这个例子中，密码/口令就如同刚才说的“密钥”。

啥是“非对称加密”？

所谓的“非对称加密技术”，意思就是说：“加密”和“解密”使用不同的密钥。这玩意儿比较难理解，也比较难想到。当年“非对称加密”的发明，还被誉为“密码学”历史上的一次革命。

由于篇幅有限，对“非对称加密”这个话题，我就不展开了。有空的话，再单独写一篇扫盲。

各自有啥优缺点？

看完刚才的定义，很显然：（从功能角度而言）“非对称加密”能干的事情比“对称加密”要多。这是“非对称加密”的优点。但是“非对称加密”的实现，通常需要涉及到“复杂数学问题”。所以，“非对称加密”的性能通常要差很多（相对于“对称加密”而言）。

这两者的优缺点，也影响到了 SSL 协议的设计。

HTTPS 协议的需求

兼容性

因为是先有 HTTP 再有 HTTPS。所以，HTTPS 的设计者肯定要考虑到对原有 HTTP 的兼容性。

这里所说的兼容性包括很多方面。比如已有的 Web 应用要尽可能无缝地迁移到 HTTPS；比如对浏览器厂商而言，改动要尽可能小；

基于“兼容性”方面的考虑，很容易得出如下几个结论：

1. HTTPS 还是要基于 TCP 来传输

   如果改为 UDP 作传输层，无论是 Web 服务端还是浏览器客户端，都要大改，动静太大了

2. 单独使用一个新的协议，把 HTTP 协议包裹起来

（所谓的“HTTP over SSL”，实际上是在原有的 HTTP 数据外面加了一层 SSL 的封装。HTTP 协议原有的 GET、POST 之类的机制，基本上原封不动）

举个例子：

如果原来的 HTTP 是塑料水管，容易被戳破；那么如今新设计的 HTTPS 就像是在原有的塑料水管之外，再包一层金属水管。一来，原有的塑料水管照样运行；二来，用金属加固了之后，不容易被戳破。

可扩展性

前面说了，HTTPS 相当于是“HTTP over SSL”。

如果 SSL 这个协议在“可扩展性”方面的设计足够牛逼，那么它除了能跟 HTTP 搭配，还能够跟其它的应用层协议搭配。岂不美哉？

现在看来，当初设计 SSL 的人确实比较牛。如今的 SSL/TLS 可以跟很多常用的应用层协议（比如：FTP、SMTP、POP、Telnet）搭配，来强化这些应用层协议的安全性。

接着刚才例子：

如果把 SSL/TLS 视作一根用来加固的金属管，它不仅可以用来加固输水的管道，还可以用来加固输煤气的管道。

保密性（防泄密）

HTTPS 需要做到足够好的保密性。

说到保密性，首先要能够对抗嗅探（行话叫 Sniffer）。所谓的“嗅探”，通俗而言就是监视你的网络传输流量。如果你使用明文的 HTTP 上网，那么监视者通过嗅探，就知道你在访问哪些网站的哪些页面。

嗅探是最低级的攻击手法。除了嗅探，HTTPS 还需要能对抗其它一些稍微高级的攻击手法——比如“重放攻击”（后面讲协议原理的时候，会再聊）。

完整性（防篡改）

除了“保密性”，还有一个同样重要的目标是“确保完整性”。关于“完整性”这个概念，在之前的博文《扫盲文件完整性校验——关于散列值和数字签名》中大致提过。健忘的同学再去温习一下。

在发明 HTTPS 之前，由于 HTTP 是明文的，不但容易被嗅探，还容易被篡改。

举个例子：

咱们天朝的网络运营商（ISP）都比较流氓，经常有网友抱怨说访问某网站（本来是没有广告的），竟然会跳出很多中国电信的广告。为啥会这样捏？因为你的网络流量需要经过 ISP 的线路才能到达公网。如果你使用的是明文的 HTTP，ISP 很容易就可以在你访问的页面中植入广告。 所以，当初设计 HTTPS 的时候，还有一个需求是“确保 HTTP 协议的内容不被篡改”。

真实性（防假冒）

在谈到 HTTPS 的需求时，“真实性”经常被忽略。其实“真实性”的重要程度不亚于前面的“保密性”和“完整性”。

举个例子：

你因为使用网银，需要访问该网银的 Web 站点。那么，你如何确保你访问的网站确实是你想访问的网站？（这话有点绕）

有些天真的同学会说：通过看网址里面的域名，来确保。

为啥说这样的同学是“天真的”？因为 DNS 系统本身是不可靠的（尤其是在设计 SSL 的那个年代，连 DNSSEC 都还没发明）。由于 DNS 的不可靠（存在“域名欺骗”和“域名劫持”），你看到的网址里面的域名未必是真实滴！，所以，HTTPS 协议必须有某种机制来确保“真实性”的需求。

性能

再来说最后一个需求——性能。

引入 HTTPS 之后，不能导致性能变得太差。否则的话，谁还愿意用？

为了确保性能，SSL 的设计者至少要考虑如下几点：

1. 如何选择加密算法（“对称”or“非对称”）？

2. 如何兼顾 HTTP 采用的“短连接”TCP 方式？

SSL 是在1995年之前开始设计的，那时候的 HTTP 版本还是 1.0，默认使用的是“短连接”的 TCP 方式——默认不启用 Keep-Alive

1. 按键盘win+r 打开运行界面，输入cmd，确定，打开管理员界面

2. 输入 netstat -aon | findstr :80

   

3. 输入 tasklist|findstr "4188" 4188是第2步骤找到的PID

   

4. 找到端口对应的服务名称,然后去关掉就行了

使用npm安装pm2 ，发现不能全局使用pm2, 于是想到去

1

ln -s node_modules/pm2/bin/pm2  /usr/bin/pm2

但是当执行pm2 命令的时候， 发现出现 Too many levels of symbolic links问题

原来/usr/bin目录下的pm2指向的是./pm2，因此，在做ln的时候只要将文件的完整目录写上去即可：

1

ln -s /etc/node_modules/pm2/bin/pm2  /usr/bin/pm2

状态码说明

DEMO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

<?php

send_http_status(404);

/**

* HTTP Protocol defined status codes

* HTTP协议状态码,调用函数时候只需要将$num赋予一个下表中的已知值就直接会返回状态了。

* @param int $num

*/

function send_http_status($num) {

    $http = array (

        100 => "HTTP/1.1 100 Continue",

        101 => "HTTP/1.1 101 Switching Protocols",

        200 => "HTTP/1.1 200 OK",

        201 => "HTTP/1.1 201 Created",

        202 => "HTTP/1.1 202 Accepted",

        203 => "HTTP/1.1 203 Non-Authoritative Information",

        204 => "HTTP/1.1 204 No Content",

        205 => "HTTP/1.1 205 Reset Content",

        206 => "HTTP/1.1 206 Partial Content",

        300 => "HTTP/1.1 300 Multiple Choices",

        301 => "HTTP/1.1 301 Moved Permanently",

        302 => "HTTP/1.1 302 Found",

        303 => "HTTP/1.1 303 See Other",

        304 => "HTTP/1.1 304 Not Modified",

        305 => "HTTP/1.1 305 Use Proxy",

        307 => "HTTP/1.1 307 Temporary Redirect",

        400 => "HTTP/1.1 400 Bad Request",

        401 => "HTTP/1.1 401 Unauthorized",

        402 => "HTTP/1.1 402 Payment Required",

        403 => "HTTP/1.1 403 Forbidden",

        404 => "HTTP/1.1 404 Not Found",

        405 => "HTTP/1.1 405 Method Not Allowed",

        406 => "HTTP/1.1 406 Not Acceptable",

        407 => "HTTP/1.1 407 Proxy Authentication Required",

        408 => "HTTP/1.1 408 Request Time-out",

        409 => "HTTP/1.1 409 Conflict",

        410 => "HTTP/1.1 410 Gone",

        411 => "HTTP/1.1 411 Length Required",

        412 => "HTTP/1.1 412 Precondition Failed",

        413 => "HTTP/1.1 413 Request Entity Too Large",

        414 => "HTTP/1.1 414 Request-URI Too Large",

        415 => "HTTP/1.1 415 Unsupported Media Type",

        416 => "HTTP/1.1 416 Requested range not satisfiable",

        417 => "HTTP/1.1 417 Expectation Failed",

        500 => "HTTP/1.1 500 Internal Server Error",

        501 => "HTTP/1.1 501 Not Implemented",

        502 => "HTTP/1.1 502 Bad Gateway",

        503 => "HTTP/1.1 503 Service Unavailable",

        504 => "HTTP/1.1 504 Gateway Time-out"

    );

    header($http[$num]);

}