工作需要把django应用的环境打包，生成exe
花了一下午踩坑pyinstaller打包，稍微memo一下
(Django==2.2.5 | Python==3.8.5 | win)

• 项目文件结构，以下称“本GM项目”

  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

  ├─.vscode ├─apps │ ├─common │ ├─DailyReport │ ├─GM_system │ ├─performance │ ├─user │ ├─。。。。。。。。。 │ └─__pycache__ ├─config ├─core │ └─__pycache__ ├─download ├─GM │ └─__pycache__ ├─log ├─mysql ├─static │ ├─css │ ├─images │ ├─js │ ├─plugins │ ├─resources ├─templates │ ├─dailyReport │ ├─layout │ ├─login │ ├─performance │ ├─public │ └─user │ └─。。。。。。。 └─__pycache__

安装pyinstaller

pip安装pyinstaller库

1

pip install pyinstaller

生成打包配置文件specfile

cd进入项目根目录，执行命令生成spec文件，文件位于当前目录下

1

pyi-makespec -D manage.py

生成的文件内容如下

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

# -*- mode: python ; coding: utf-8 -*-

block_cipher = None


a = Analysis(['manage.py'],
             pathex=['D:\\SVN\\GMs\\03_Source\\trank\\GMsV3.0'],
             binaries=[],
             datas=[],
             hiddenimports=[],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             win_no_prefer_redirects=False,
             win_private_assemblies=False,
             cipher=block_cipher,
             noarchive=False)
pyz = PYZ(a.pure, a.zipped_data,
             cipher=block_cipher)
exe = EXE(pyz,
          a.scripts,
          [],
          exclude_binaries=True,
          name='manage',
          debug=False,
          bootloader_ignore_signals=False,
          strip=False,
          upx=True,
          console=True )
coll = COLLECT(exe,
               a.binaries,
               a.zipfiles,
               a.datas,
               strip=False,
               upx=True,
               upx_exclude=[],
               name='manage')

其中exe项里的name值为生成exe的文件名
console项表示运行是否显示控制台终端
若需要指定生成exe文件的图标，则可以在其中新增一项icon，如icon='favicon.ico'

打包生成exe

• 运行如下命令打包项目生成exe

  1	pyinstaller manage.spec

  打包时似乎会将当前python环境里安装的所有包都打包进去
  可能报一些和最终生成无关的其他包的依赖错误等，打包时会较慢
  并且可能会由于打包进了很多无关项目的包而导致最终生成的目录大小较大
  虽说可能无关紧要可以忽略，但强迫症可能就难受了，可以事先准备一个没有多余包的纯净python环境

生成后项目目录结构将会多出build与dist目录
dist目录即为生成的打包项目，exe生成在dist\manage\目录里

• 运行项目

  1 2	rem cd进入manage.exe的目录下 .\manage.exe runserver

踩坑Start

hiddenimports配置

直接生成exe后运行报错提示如No module named XXX
这是因为打包后的Django有些module不会自动收集，需要手动添加
需要在spec文件中修改hiddenimports列表，将未导入的包添加进去
如下为这次在GM项目中修改的hiddenimports

1
2
3

hiddenimports=["core.perms", "corsheaders", "corsheaders.middleware", "django.middleware.common",
             "django.contrib.auth.templatetags", "apps.suloss.templatetags", "apps.efwpf.context_processors",
             "django.contrib",],

TemplateDoesNotExist

解决上面的问题之后应该就能正常启动项目
但是打开网页就会报TemplateDoesNotExist，找不到前端模板
由于打包程序只讲python代码部分打包，所以template需要自行复制到打包后的项目目录中
根据错误的提示消息，把项目中的模板文件templates拷贝到相应的位置，刷新页面即可。

于GM项目，我将templates目录复制到dist\manage\下即可

xx静态资源xx lost

既然template都没有被打包进去，那么项目引用的静态资源更不必说了
解决完上述问题后网页或许可以打开，但引用的本地的静态css和js都会404 not found
这里的解决方法如下

1. 首先在项目的settings.py文件中添加如下代码，其中static是项目中的静态文件位置，static_root是static下的一个空文件夹，然后执行python manage.py collectstatic命令将静态文件收录到static_root中

   1	STATIC_ROOT = os.path.join(BASE_DIR, 'static', 'static_root')

2. 然后在项目的urls.py文件中添加如下代码

   1 2 3 4 5

   from django.conf.urls import static from project_1 import settings # project_1记得改成项目settings所在的目录名 urlpatterns += static.static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

到这里之后再重新打包生成项目即可√

anything else

下面问题可能只与本GM项目相关，仅供参考

log目录

解决上述问题后启动仍报错：ValueError: Unable to configure handler 'collect'，出在log相关的代码处
上面也报有FileNotFoundError: [Errno 2] No such file or directory: 'D:\\SVN\\GMs\\03_Source\\trank\\GMsV3.0\\dist\\manage\\log\\collect.log'的错误，想必是并没有生成log目录，也无法在不存在的目录下写入collect.log等log

解决方法即照报错信息，在打包项目目录下新建log目录即可

conf目录

启动时报错[16508] Failed to execute script manage
具体报错FileNotFoundError: [Errno 2] No such file or directory: 'D:\\SVN\\GeneralMills\\03_Source\\trank\\GeneralMillsV3.0\\dist\\manage\\config\\email.json'
报错处代码读取该文件失败，观察打包的项目中并无config目录，更不会有email.json文件

GM项目中数据库配置与email配置放在config目录中未被打包，将原项目中config目录复制到打包的项目中即可
然而坑爹的是，可能与项目代码读取配置文件的方式有关，读取的目录总是在启动项目命令执行的当前目录中，若在桌面或其他目录中使用exe的绝对路径启动项目，项目会在当前执行的目录中尝试读取config目录的文件
这点会影响到之后批处理/运行脚本的编写，即需要cd到exe所在目录中后再运行

静态资源请求被中间件拦截

上面两个问题简单来说就是“缺啥补啥”，然而本项目中更坑爹的事情出现了。。
进入页面之后退出登录，进入login界面时，页面竟然渲染不了样式和js，F12查看所有资源均为200正常请求资源，这就很奇怪了
后来点进去那些请求回来的静态资源，发现无论css或者是js全部变成了
<html><body onLoad="alert('登录过期, 请重新登录！');window.top.location.href='/login'" ></body></html>
同时提醒后发现，退出登录状态后，验证权限的中间件将静态资源请求也拦截了下来，
原本用django manage.py直接启动时，django会处理本地静态资源所以并不会被拦截
然而打包的exe启动后，所有的静态资源请求也变成了“外部请求”，请求会走中间件，于是被拦截
解决方法即最后在中间件中判断若请求为/static/开头则放行

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

def process_request(self, request):
    request_url = request.path_info
    # print(request_url)
    for url in settings.SAFE_URL:
        if re.match(url, request_url):
            return None

    ######
    if request_url.startswith('/static/'):
        return None
    ######

    userInfo = request.session.get('userInfo', None)

    if not userInfo:
        return self.is_ajax_return(request, "登录过期, 请重新登录！")

参考链接

Django框架14 /pyinstaller打包django项目成exe文件
pyinstaller打包django项目
bat脚本创建桌面快捷方式

最近工作相关项目有些功能写了/搜集了一些日期时间相关处理的函数，做个笔记
Javescript / Python

日期格式化相关

• 输入时间戳(number)或其他字符串格式的日期，会转化成年月日形式输出日期，默认分隔符为‘-’

  1 2 3 4 5 6 7

  let formatTime = function(time,spliter = '-') { let date = new Date(time); let year = date.getFullYear(); let month = (date.getMonth() + 1) >= 10 ? (date.getMonth() + 1) : '0' + (date.getMonth() + 1); let day = date.getDate() >= 10 ? date.getDate() : '0' + date.getDate(); return `${year}${spliter}${month}${spliter}${day}` }

日期计算相关

• 输入两日期d1&d2，计算d1-d2两天数相差的天数

  1 2 3 4 5 6 7

  let getDateDeltaDays = function(d1, d2) { // return d2 - d1 var a1 = Date.parse(new Date(d1)); var a2 = Date.parse(new Date(d2)); var day = parseInt((a2-a1)/ (1000 * 60 * 60 * 24));// 时间戳相减，然后除以天数 return day }

• 输入日期start_date与天数day，计算从start_date起day天后的日期

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

  let getDay = function(start_date, day) { function doHandleMonth(month){ // month若为个位数则前面加0 var m = month; if(month.toString().length == 1){ m = "0" + month; } return m; }; var start_date = new Date(start_date) var targetday_milliseconds=start_date.getTime() + 1000*60*60*24*day; start_date.setTime(targetday_milliseconds); //注意，这行是关键代码 var tYear = start_date.getFullYear(); var tMonth = start_date.getMonth(); var tDate = start_date.getDate(); tMonth = doHandleMonth(tMonth + 1); tDate = doHandleMonth(tDate); return tYear+"-"+tMonth+"-"+tDate; }

分割 / 范围

• 输入一个日期范围start_date ~ end_date，将按照divideDays的天数将日期范围分割，默认30天分割

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

  let divideDateRangeList = function(start_date, end_date, divideDays=30) { let result = [] start_date = start_date === null ? null:start_date end_date = end_date === null ? null:end_date if(!start_date || !end_date) return result if(getDateDeltaDays(start_date, end_date)+1 <= divideDays) result.push({start: start_date, end: end_date}) else { start = start_date while(getDateDeltaDays(start, end_date)+1 > divideDays) { end = getDay(start, divideDays) tmp = {start:start, end:end} result.push(tmp) start = getDay(end, 1) } tmp = {start: start, end: end_date} result.push(tmp) } return result }

• 输入一个日期范围start_date ~ end_date（需按照‘年-月-日’格式），将返回包含期间所有日期的列表

  • Javascript
  • python

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

  let getDateRange = function(start_date,end_date) { range_list = [] start_date = start_date ? start_date: null end_date = end_date ? end_date: null if(!start_date || !end_date) return range_list start_date = start_date.split('-') end_date = end_date.split('-') start_date = new Date(start_date[0], start_date[1]-1, start_date[2]).getTime() end_date = new Date(end_date[0], end_date[1]-1, end_date[2]).getTime() for(let i = start_date; i<= end_date;) { range_list.push(formatTime(i, '-')) i += 24*60*60*1000 } return range_list }

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

  import datetime def rangeDate(start, end): result = [] start_date = datetime.datetime.strptime(start, '%Y-%m-%d') end_date = datetime.datetime.strptime(end, '%Y-%m-%d') step = datetime.timedelta(days=1) while start_date!=end_date: result.append(str(start_date.date())) start_date += step result.append(end) return result

Nginx做静态资源服务器是一个十分基础的应用了，但是一般默认是不会将静态资源的目录直接列出来的。不过要想直接列出目录内的文件，做一个目录文件列表也是他原生的功能，配置也十分简单，只需要配置autoindex项即可。
一般在网络上很容易见到的一些资源站、下载站之类的、甚至是某些镜像站，也是通过配置nginx的autoindex实现的，如下图页面

autoindex配置

配置项相关

autoindex项的默认值是off，开启目录列表只需要在server或者location块里配置autoindex on;即可
我下面的示例是会在location路由块里配置，主要还是觉得在location块里设置会比较好

当然除了配置autoindex项之外，还有一些其他的配置项，如下表

这里贴出一段示例的配置

1
2
3
4
5
6
7
8
9

location /dl/ {
    root /home/flyky/fileindex/;
    charset utf-8;

    autoindex on;
    autoindex_exact_size off;
    autoindex_format html;
    autoindex_localtime on;
}

关于 root 与 alias

上面示例配置中，列出的目录在主机上的位置是/home/flyky/fileindex/dl/
上面使用的是root指令来配置服务请求的根目录，因为要列出的是fileindex下的dl目录，所以在root项中应该配置dl所在的fileindex目录为根目录，然后在location配置dl目录的路由
也就是说，root配置的是资源的根目录，是所要做文件列表展示的目录的『所在目录』或者说是『上层目录』，而不是被展示列表的那个目录 ，并且要确保location路由的目录，也就是目录dl在fileindex目录下

当然，上面说得这么绕，还有一种情况，使用alias就好理解一点了
alias即别名，也就是给服务请求的目录起了一个别名，譬如配置/home/flyky/fileindex/dl/的目录的路由为/download，我们可以这样写

1
2
3
4

location /download/ {
    alias /home/flyky/fileindex/dl/;
    autoindex on;
}

假设server为localhost，监听8080端口，这里我们访问localhost:8080/download/浏览到的就是dl目录，之后访问的uri内所有的/download/都会被替换成/home/flyky/fileindex/dl/目录，相当于是给dl目录起了个别名download，也有点类似与linux里的目录软链接
但是这里有个坑，由于这个alias实际是用的“替换”路径，所以在配置location项的路由名后面一定要加上/，比如上面例子的/download/，如果不加上斜杠的话，比如要访问主机dl/test.png图片资源，那在浏览器中应该访问的地址是servername:port/dowload/test.png，服务器访问会被替换成dltest.png，一定会报404 not found的。
当然如果使用root设置根目录的话就没必要后添斜杠了，location配置直接/download就可以

其他

注意访问的目录权限，如果nginx无法访问到该目录报了403 forbidden错误的话，大概率是权限问题
查看配置的目录的访问权限以及所有者，启动nginx的用户是否可以访问该目录
另外最好不要设置访问/root，普通用户无法访问root目录下的文件，如果一定要设置root目录或者其他root用户权限目录下的目录，可以更改nginx的配置文件，将user项配置成root用户。

autoindex页面的美化

配置好的autoindex页面效果极度简洁，并不美观，如果想要赏心悦目那必定还得一番折腾

安装 ngx-fancyindex 插件

首先需要给Nginx安装ngx-fancyindex插件，安装方法还是编译安装，之前的博文已经具体写过nginx编译安装了，这里也不赘述了。这里只描述给已安装的nginx添加插件的过程

使用2>&1 nginx -V | tr ' ' '\n'|grep module命令可以查看当前nginx编译安装好的模块

首先在nginx源码包目录下下载解压插件ngx-fancyindex源码，直接git clone也好

1

git clone https://github.com/aperezdc/ngx-fancyindex.git ngx-fancyindex

然后将 --add-module=ngx-fancyindex \ 添加到configure配置中执行configure
如果没有用Nginx编译安装指北这篇博文里的configure脚本的话，可以使用nginx -V，可以查看到当初安装nginx的configure参数配置。

configure执行后make编译，编译结束后不需要make install了（当然如果你还没有安装nginx的话直接make install就可以了）
进入nginx源码目录下的objs目录，可以看到编译好的nginx可执行程序文件
首先执行2>&1 ./nginx -V | tr ' ' '\n'|grep fan查看是否编译了插件，没问题了之后再把objs/nginx复制替换到安装位置的nginx就可以了，我的configure参数设置了sbin-path为/usr/sbin/nginx,所以我只需要把objs下的nginx复制到/usr/sbin/即可。

fancyindex主题安装配置

插件安装好之后就可以使用fancyindex主题了。
去github搜fancyindex-theme就能看到很多别人写好的主题，随便选一个，然后根据文档进行配置即可

我这里是使用的是Naereen/Nginx-Fancyindex-Theme，也有使用文档
使用效果如图

其实主题安装配置过程讲起来也就几步

• 首先下载主题解压到网站根目录，或者git clone到网站根目录
• 然后在nginx的配置autoindex的location块中引入fancyindex配置文件
  include /your/website/root/fancyindex.conf
• 之后你也可以修改fancyindex配置文件，譬如我使用的这个主题可以配置light或dark两种配色主题等

这里要注意主题要放在网站根目录，同时也要配置好location /的路由

参考资料

Nginx浏览目录配置及美化

今天写这篇的原因是刚好在搭建一个东西需要用到redis环境，关于原因也就不多说了。
Redis是什么这种问题也不具体说了，就是一个基于内存的数据库软件。这边贴一段百科的介绍，具体的可以自己去查资料。

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

这篇的操作是基于linux的安装，redis版本5.0，Windows可以退散了。
这边就不扯其他的了，单刀直入地讲了

源码编译安装

为什么选择源码编译安装，这点我在介绍【nginx编译安装】那篇博文里讲过一点原因，redis的话主要还是因为软件包管理安装的版本比较老吧。

惯例编译安装前需要安装gcc和make，如果是ubuntu可以直接安装build-essential，这点我在nginx编译安装那篇也说过了，不赘述。

首先在官网下载redis源码包后解压，进入解压的源码包目录直接make、make install两步走就行了

这边make install默认的redis安装位置在/usr/local目录下，二进制文件在/usr/local/bin，不是root用户的话可能需要sudo
如果需要改变安装位置的话可以在make install后指定PREFIX
譬如make install PREFIX=/usr/local/redis修改安装位置在/usr/local/redis下，二进制文件就在/usr/local/redis/bin里。

我这里还是按照默认的位置安装，这样的话安装完成后可以直接使用redis-server测试运行一下。

配置文件

redis源码包里有示例的配置文件，我们直接使用即可，不过建一个专门存放redis配置文件的目录比较好，一般软件的配置文件都放在/etc下
我们就在/etc下创建一个redis的目录用来存放redis的配置文件，然后把源码包下的示例配置文件复制过去，并重命名为6379.conf

1
2

sudo mkdir /etc/redis
sudo cp /your/redis/redis.conf /etc/redis/6379.conf

这里重命名的6379是redis默认的启动端口。

现在修改一下6379.conf这个配置文件
将里面的daemonize no改为yes，启用后台运行

添加服务项

这边参考了这篇博文的内容，感兴趣可以看看

关于linux的系统服务管理的说明

linux的系统服务管理命令主要有两个，service和systemctl。
现在新版本发行版的linux基本上都是用systemctl，然后service命令也可以使用，但是执行时会被重写成systemctl命令，所以实际上用的还是systemctl。服务项的配置一般是放在/etc/systemd/system或者/lib/systemd/system下的，这个根据发行版本不同略有区别，自行确认。
老一点的发行版本可能用的就是原来的service命令，它的命令脚本位置一般在/etc/init.d或者/etc/rc.d/init.d下，根据发行版本不同略有区别，自行确认。

这边接下来就根据这两个不同情况来说明配置方法:

systemctl(systemd)

上面也说过了，服务配置可能放在/etc/systemd/system或者/lib/systemd/system下，自行确认。
现在服务配置的目录下新建一个redis.service脚本，内容如下

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

[Unit]
Description=Redis
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/var/run/redis_6379.pid
ExecStart=/usr/local/bin/redis-server /etc/redis/6379.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

这里要注意，里面变量的具体值要是你自身安装的实际情况自行修改，譬如你修改了安装位置，那么ExecStart项里redis-server的绝对路径肯定也是要修改的
然后提一下这个PIDFile的值是和6379配置文件里的pidfile项一致。

接下来重载一下系统服务，就可以使用redis服务了

1
2
3
4
5

systemctl daemon-reload  # 重载系统服务

systemctl start redis # 启动redis服务
systemctl status redis # 查看redis服务状态
systemctl stop redis # 停止redis服务

service(init.d)

一开始也说过了，服务配置脚本位置可能在/etc/init.d或者/etc/rc.d/init.d下，自行确认
在redis的源码包下的utils目录里有redis服务的启动脚本，我们只需要将它复制到系统服务配置的目录下即可，这里假设是/etc/init.d

1

sudo cp /your/redis/utils/redis_init_script /etc/init.d/redis

然后将下面两行的内容添加到redis启动脚本的第二、三行（也就是#!/bin/sh的下面）

1
2

# chkconfig: 2345 90 10
# description: Redis is a persistentkey-value database

指的是redis服务必须在运行级2，3，4，5下被启动或关闭，启动的优先级是90，关闭的优先级是10。

接下来就可以添加并使用服务了

1
2
3
4
5
6

chkconfig --add redis       # 如果没报错的话，说明成功，可以用
chkconfig --list            # 查看所有服务

service redis start         # 启动redis服务
service redis status         # 查看redis服务状态
service redis stop         # 关闭redis服务

在之前【自建git服务实现hexo博客部署】这篇博文中提到了如何自建git服务远程仓库。这种方式需要在远程端输入命令来创建仓库和配置，比较麻烦，更希望可以搭建一个像github一样的web环境来方便地进行管理仓库以及配置。
突然想到chino把TIS外服的白名单放在自建的git服务下托管，每个部落的管理即使不懂得git也可以在网页上管理各自的白名单。一看原来是用Gogs搭建的
上网搜了一下还有很多人推荐Gitea，gitea是从Gogs源码的基础上开发的，听说使用起来也很不错，而且维护更新也更频繁，于是我就选择了Gitea
官方也是很有趣，官网上写着 「Git with a cup of tea」，这大概也是gitea名字的含义吧。

Gitea 是一个开源社区驱动的轻量级代码托管解决方案，后端采用 Go 编写，采用 MIT 许可证

先来看一下我部署好的gitea的首页界面

安装MySQL数据库

Gitea需要有数据库，支持postgresql、mysql、sqlite，那我这里还是选择MySQL。我们选择安装软件源，用包管理安装

下载软件源

首先要下载软件源，去MySQL的官网下载站点下载软件源，我这里用的是CentOS，所以我使用Yum Repository

选择相应系统版本的软件源下载，然后点击右侧的小感叹号（红框框出），在下面会有链接跳转到用该软件源安装的quick guide（指南），里面会详细的讲解如何使用软件源安装mysql

1

sudo rpm -Uvh mysql80-community-release-el7-3.noarch.rpm

1

yum repolist all | grep mysql

1
2

sudo yum-config-manager --disable mysql80-community
sudo yum-config-manager --enable mysql57-community

1

yum repolist enabled | grep mysql

1

sudo yum install mysql-community-server

1
2
3

sudo service mysqld start
# 或者
sudo systemctl start mysqld.service

1

grep 'temporary password' /var/log/mysqld.log

1

alter user 'root'@'localhost' identified by 'your-new-passwd';

安装Gitea前的准备

创建git用户（组）

1
2

groupadd git
useradd -g git git -s /bin/git-shell

上面命令创建了一个git用户并加入了git用户组（并且为了安全禁止使用shell登录，这个创建用户后也可以在/etc/passwd文件里修改），我们接下来就用这个git用户运行gitea程序。

当然这一步不做也可以，不用git用户的话用当前用户或者root用户也可以，只是在配置gitea的时候要注意一下

创建gitea数据库

使用下面的sql代码创建gitea数据库
注意将示例代码中的gitea、gitea_user、gitea_password替换成实际的内容

1
2
3
4

create database gitea DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE USER 'gitea_user'@'localhost' IDENTIFIED BY 'git_password';
GRANT ALL PRIVILEGES ON gitea.* TO gitea_user@localhost IDENTIFIED BY 'gitea_password';
FLUSH PRIVILEGES;

启动并配置Gitea

启动Gitea与安装配置

第一次启动gitea

1
2

chmod +x gitea
./gitea web

web默认端口在3000，打开gitea页面之后，随便点击界面上的按钮（注册，登录之类的），或者在地址后加上/install，会跳转到『初始配置』页面进行安装前的配置，如下图：

这里的配置按照自己的实际情况来就可以了，配置完之后安装即可
配置之后也是可以更改的，gitea的配置文件在gitea/custom/conf/app.ini
具体的配置项可以去官方文档查看，也可以在本文的参考文章里的文章里查看

创建gitea service来启动Gitea

这里配置的是systemctl命令的系统服务。关于linux的系统服务管理相关，我在这篇博文中提过，建议先去了解一下。

由于我们创建的git账户无法使用shell登录，不好直接用git用户启动gitea，我们选择创建一个服务来启动关闭gitea。下面的创建服务的位置要根据你自己系统的service文件的实际位置改变，我这里是centos，所以在/etc目录下

1

vim /etc/systemd/system/gitea.service  #创建gitea.service

下面是一份示例，可以根据实际情况修改

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

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/usr/program/gitea/
ExecStart=/usr/program/gitea/gitea web -c /usr/program/gitea/custom/conf/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/usr/program/gitea
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target

之后就可以通过service gitea start，service gitea stop，service gitea status
或者systemctl start gitea，systemctl stop gitea，systemctl status gitea来开关和查看状态了

Nginx反向代理设置

如果需要用nginx反向代理的话。
这次我贴出一份完整的我的nginx配置(当然域名和证书路径还是假的啦)
我用了ssl证书，监听80重定向到443

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

server {
    listen 80;
    server_name git.example.com  git.example.cn;
    rewrite ^(.*)$ https://${server_name}$1 permanent;
}

server {
    listen 443 ssl;
    server_name git.example.com  git.example.cn;

    ssl_certificate /your/ssl/certificate/location;
    ssl_certificate_key /your/ssl/certificate/key/location;
    ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:1m;
    ssl_session_timeout 5m;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Nginx-Proxy true;
    }
    expires max;
}

参考文章

• CentOS 安装 Gitea 和错误处理

我们在使用let's encrypt获取免费的HTTPS证书的时候，let's encrypt需要对域名进行验证，以确保域名是你自己的
之前用默认的文件验证方式总有奇怪的问题导致失败，我也是很无奈，于是改用验证DNS-TXT记录的方式来验证，而且貌似如果申请泛域名证书也只能通过这个方式验证

本来呢我只打算在这篇记一下验证DNS记录的方式签发证书，不过以前也没写过如何用certbot签发免费Let’s Encrypt SSL证书诶，那正好就重头把过程写一遍。

安装Certbot

根据官网提示步骤安装

先去Certbot 官网，在网页上选择使用的服务器软件和系统版本，会跳转到安装的文档，
根据提示的步骤安装即可

使用自动安装脚本安装

1
2

wget https://dl.eff.org/certbot-auto
chmod a+x certbot-auto # 给脚本执行权限

接下来直接使用该脚本进行签发证书等操作即可
第一次使用该脚本时会自动安装依赖。

获取签发证书（standalone）

直接使用certbot certonly命令即可开始签发，根据提示，先选择模式，一般选择standalone（使用standalone需要先停止nginx等服务器运行），然后根据提示列出需签的域名，之后会开始验证，通过之后会将生成的证书文件保存。

获取泛域名签发证书（manual，通过DNS-TXT记录来验证域名有效性）

1

certbot certonly  --preferred-challenges dns -d "*.example.com" -d example.com --manual

用这个命令来手动验证DNS签发
这里我用example.com来假设要签的域名，-d后面跟着一个域名，如果有多个域名要签的话记得每一个单独的域名前都要写-d。
我指定了两个-d参数，因为certbot的泛域名其实只支持诸如*.example.com，如要直接使用example.com，就得为其单独也签发一条。

回车执行之后，会开始提示你给你的域名添加TXT解析记录。如下图：

这里是提示你为域名添加一个_acme-challenge的TXT记录，记录值为生成的一串字符（图中红框）。
这个只需要你去DNS服务商那里添加即可，这里如果你 -d 了几条不同的二级域名，那每个二级域名都要添加记录；在你添加完一个域名的记录值，在控制台回车之后会提示你下一个域名的记录值

在你添加完记录保存之后，最好要检查一下解析记录。
在其他终端输入下面命令（示例example.com，记得修改）：

1
2
3

nslookup -type=txt _acme-challenge.example.com 8.8.8.8
# 或者
dig -t txt _acme-challenge.example.com

如果包含你所添加的记录值，那么说明添加成功

那现在就可以控制台继续回车，不会意外就会把签发的证书文件保存，控制台打印出来证书文件的存放位置，一般情况下是会保存在/etc/letsencrypt/live/example.com目录下

这个目录下一般会有四个文件：

我们一般用fullchain.pem和privkey.pem就可以了

在Nginx配置使用证书

这里我就不展开说了，监听的443端口设置ssl_certificate和ssl_certificate_key基本上就可以了
我这里贴上我自己的一段示例

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

server {
    listen  443 ssl;
    server_name example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_session_timeout 10m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    ssl_prefer_server_ciphers on;

    location / {
        # 你自己配置;
    }
}

证书续期与注销

续期

免费的let's encrypt有3个月的时间，到期前需要续期
第一次使用certbot签时如果输入了邮箱地址，证书快到期前是会发邮件提醒你的
使用下面的命令续期

1

certbot renew --dry-run

设置自动续期

设置自动续期的话，只需要写脚本放在Cron中定时运行即可，crontab -e打开crontab脚本，添加如下的脚本

1

0 3 */7 * * /bin/certbot renew --renew-hook "/where/your/nginx -s reload" 

这个脚本表示每隔 7 天，夜里 3 点整自动执行检查续期命令一次。续期完成后，重启 nginx 服务
添加完后重启cron服务即可sudo service crond restart

泛域名通过DNS-TXT记录(自动)续期

这个就稍微麻烦一点，我们需要使用到DNS服务商提供的API，在renew证书时可以自动添加更新TXT记录来实现自动更新，当然一般还需要DNS服务商给用户提供的API密钥确保安全等
我先列出一些DNS插件的地址，具体的可以去查看插件安装使用方法，当然其他第三方的DNS插件也可以在github里找找

• certbot提供的DNS插件列表
• 阿里云DNS插件
• dnspod插件（腾讯云）

我这里使用的是DNSPOD，于是我也就只描述以下使用dnspod插件的情况

1. 下载certbot-auth-dnspod脚本

   1 2	wget https://raw.githubusercontent.com/al-one/certbot-auth-dnspod/master/certbot-auth-dnspod.sh chmod +x certbot-auth-dnspod.sh

2. 获取用户DNSPOD token
   登录dnspod后，在控制台的用户中心 -> 安全设置下找到「API Token」，开启并创建token后，复制下id和token
3. 配置token信息

   1	echo "id,token" > /etc/dnspod_token

   把`id`和`token`换成刚刚复制下来的真实内容 接下来就可以**使用插件进行续期**了

   1	certbot renew --manual --preferred-challenges dns --manual-auth-hook /path/to/certbot-auth-dnspod.sh --force-renewal

如果要自动续期，就可以将下面的代码加入crontab中再重启cron服务，具体的过程上面说过了，这里也不再赘述

1

29 3 1 * * root /bin/certbot renew --manual --preferred-challenges dns  --manual-auth-hook /path/to/certbot-auth-dnspod.sh --force-renewal --post-hook "/where/your/nginx -s reload"  

这是每个月1号3点29分执行一次强制证书更新后重启nginx

当然用插件进行申请证书自动DNS验证也是可以的

1

certbot certonly --manual --preferred-challenges dns-01 --email mail@domain.com -d laravel.run -d *.example.com --server https://acme-v02.api.letsencrypt.org/directory --manual-auth-hook /path/to/certbot-auth-dnspod.sh 

注销

使用下面的命令可以查看已生成的证书信息，包括证书名称，包含的域名，到期时间以及证书文件路径

1

certbot certificates

找到你要注销的证书，复制下证书文件的路径，然后使用下面的命令注销

1

certbot revoke --cert-path   /etc/letsencrypt/live/example.com/fullchain.pem

之前一直不太了解『对象存储是个什么玩意儿』。只是在腾讯云阿里云都见到过，但是不清楚也不太想了解

今天突然想了解它的契机是图床来着。
在我配置压缩博文的过程中，需要把图片资源压缩，我选择了webp。正当我要把webp文件传到图床的时候，却发现常用的图床都不支持webp。 于是突然爱折腾的我想着『自建图床』，这才去百度上一搜，发现很多推荐『七牛云』的『对象存储』服务。这我就突然想起来了，腾讯云阿里云不也有这玩意嘛，于是我就想到用我现在常用的「腾讯云」来弄。

对象存储可以简单理解为用来存储图片、音频、视频等非结构化数据的数据池。相对于主机服务器,具有读写速度快,利于分享的特点。

就像个云盘一样

创建腾讯云对象存储服务COS（Cloud Object Storage）

打开腾讯云官网，登陆后来到控制台，激活COS服务，然后再概览中就会看到提示『创建存储桶 』

存储桶（bucket），顾名思义，我们将把要存储的对象文件存储在这个桶里
点击「创建存储桶」，名称随意，地域随意
访问权限选择「公有读私有写」，然后就可以点「确定」

在控制台左侧栏里除了「存储桶列表」还有「资源包管理」，点进去可以看到当前有效的资源包以及购买资源
这里的资源包主要包含容量资源包以及流量资源包*，因为容量和流量是计费的项目，详细的可以去看腾讯云的计费定价
买了对应存储桶的所在地区对应的资源包，就可以直接抵用该桶的消费
*当然目前这个时间点腾讯云是赠送新手一定量的容量资源包的，还有1元新手容量包

COS存储桶的使用

存储桶控制台 / 上传文件等

点进刚刚创建好的存储桶，在「文件列表」里可以看到上传在该桶之中的文件(夹)
在这里可以直观的在桶里进行上传文件，创建文件夹等操作
那我这里专门创建了一个文件夹，用于存储博客用到的图片资源，给博客提供图床外链

获取外链

将你想要分享的文件上传到桶里之后，在该文件的右边点详细信息，可以看到该文件对象的基本信息，包含名称，大小，时间，下载文件对象等,

倒数第二项是「对象地址」，这个便是该文件的外链了，点击复制按钮，贴在博客里，便可以实现它的图床功能啦

当然不仅仅是图片，音乐视频都可以上传在桶里，外链贴在博客等需要他的地方，相当容易

你可能注意到了最后一项的「临时链接」，这个是由于外链可能有一些权限限制访问，或者是向下面提到的「防盗链」设置后，我们就不能直接通过外链访问这个文件对象了
临时链接带有签名参数，但有时间限制，可以用该链接暂时直接访问，但是这个链接不要用在博客等做外链，外链还是得用上面的对象地址。

COSBrowser客户端操作腾讯对象存储（推荐）

腾讯云官方为我们提供了COS客户端，Windows/Mac/Linux/iOS/Android主流系统都有，十分方便
这下对象存储真的可以当云盘用了（笑:-D
拉开控制台最左侧栏里可以看到「工具」- > 「客户端下载」，下载对应的客户端使用即可

那我这里就不具体描述客户端的使用了，就放一下客户端的界面图，是我使用的Linux和Android端

防盗链设置

防盗链设置还是挺重要的，如果被盗链会导致你的流量费用可能会跑的极快呢
在存储桶的基础配置里可以找到「防盗链设置」，在该项里设置即可
下图是我的设置，以白名单类型为例，在Referer里添加可以访问的域名或地址即可

保存设置之后，只有白名单里的域名地址才可以访问外链了。
即使其他人获取到链接也无法访问相应图片

自定义源站域名访问外链

默认的访问域名是腾讯云分配的公共域名，使用起来没有任何问题，就是太长了。。所以这里我们可以用自己的域名绑定到对应的存储桶里去生成访问外链。
这样做的另一个好处是，假设换了一个存储桶，我们可以通过接口将原桶文件转移过去，但是用了新桶的默认访问域名，这样会导致原本访问文件的链接不同，你写在博客里的外链会失效，然而如果用自定义访问域名，只需要换绑域名到新桶即可，只要桶内的文件目录没有变化，文件生成的外链也就不会变了。

设置存储桶自定义访问域名

在控制台点进需要设置的存储桶，可以看到「域名设置」，在里面可以看到「自定义源站域名」这一项
点击添加域名，填写内容即可。这里「源站类型」选择「默认源站」，然后将CNAME项的值复制下来，下一步解析域名需要使用
另外根据要求，自定义的域名必须经过备案

添加域名解析记录

DNS服务商处设置好对应的CNAME记录即可，下图示例
记录值填写上一步复制下来的CNAME项的值

等待生效即可

获取对象文件自定义域名访问外链

这一步和之前获取外链是一样的
在文件的基本信息里，将「指定域名」选择成「自定义源站域名」再选择刚刚新建的域名，这样在下面的对象地址就会生成自定义的域名外链了
当然其实你只需要把获取到的默认域名的对象地址里的域名改成你自定义的域名即可。

一直以来我的hexo博客都是用自带的server跑，然后nginx反代，说白了hexo s只是用于生产环境下使用的，我却一只用于部署。没用到hexo生成静态页面和部署，有点遗憾也有不少的弊端。
但是hexo deploy大多数人是部署到github上，我并不想用github的域名，也不想部署到github上再把自己的域名解析CNAME到上面，因为国内github的访问时不时就有问题，而且这样有一种“寄人篱下”的感觉，很不爽。
于是就得自建git服务再部署了。
所幸过程也并不繁琐，简单来说也就下面几步：

1. 先建立git服务，配置好远程仓库
2. 在hexo配置中设置push到远程仓库
3. 设置git hook，钩子把静态资源拷贝到自定义网站目录
4. nginx配置web server
   剩下的就用hexo原生的生成静态文件，上传部署，两步走即可

下面讲讲详细过程

在服务器上搭建git服务并配置

当然首先服务器上得装好git，用软件包管理安装即可，不多赘述

创建git用户

这里我们创建一个git用户，用来运行git服务

1

sudo adduser git

设置免密登录（ssh密钥对）

由于你的本地Git仓库和Git仓库之间的传输是通过SSH加密的，所以之后本机hexo部署上传需要设置密钥登录
首先在本地机生成密钥对ssh-keygen -t rsa

收集所有需要登录的用户的公钥，就是他们自己的id_rsa.pub文件，把所有公钥内容导入到/home/git/.ssh/authorized_keys文件里，一行一个。
这里我们就直接把本地的~/.ssh/id_rsa.pub内容直接复制添加到服务器的/home/git/.ssh/authorized_keys文件即可。

之后本机尝试免密登录服务器git用户ssh git@server.ip，如果可以表示之前的设置无误。
那现在我们为了安全起见就可以禁用git用户登录shell了
编辑服务器/etc/passwd文件，找到类似下面的这行
git:x:1001:1001:,,,:/home/git:/bin/bash
将其改为
git:x:1001:1001:,,,:/home/git:/usr/bin/git-shell
即可。这样，git用户可以正常通过ssh使用git，但无法登录shell。

初始化远程Git仓库

首先自定义git仓库位置，假定是/home/git/blog.git，在/home/git目录下输入命令

1

sudo git init --bare blog.git

Git就会创建一个裸仓库

然后我们把该目录的owner改为git

1

sudo chown -R git:git blog.git

现在我们在本地随便什么地方，试试clone这个裸仓库，如果没问题即可

1

git clone git@server.ip:~/blog.git 

设置git hook（钩子）

首先cd到远程仓库的hooks目录下，cd /home/git/blog.git/hooks
之后创建并编写post-receive文件，vim post-receive

1
2
3
4
5
6
7
8

#!/bin/bash -l
GIT_REPO=/home/git/blog.git
TMP_GIT_CLONE=/home/git/tmp/blog
PUBLIC_WWW=/home/git/project/blog
rm -rf ${TMP_GIT_CLONE}
git clone $GIT_REPO $TMP_GIT_CLONE
rm -rf ${PUBLIC_WWW}
cp -rf ${TMP_GIT_CLONE} ${PUBLIC_WWW}

其中public_www就是用于最终存放nginx映射的静态资源文件目录
* 通过此脚本，每次仓库接收到新上传的内容时都会自动拷贝资源到该目录下 *

这里的tmp目录可能要自己新建，mkdir /home/git/tmp即可。

然后记得更改脚本和各个目录的权限

1
2
3
4
5
6

chmod +x /home/git/blog.git/hooks/post-receive
chmod 777 -R /home/git/blog.git
chmod 777 -R /home/git/project
chmod 777 -R /home/git/tmp

chown -R git:git /home/git/

在hexo配置中设置push到远程仓库

修改hexo工程的_config.yml文件，在deploy项中填写：

1
2
3
4
5

deploy:
    type: git
    message: update
    repo: git@server.ip:~/blog.git
    branch: master

Nginx 配置

这一步熟悉Nginx的小伙伴应该可以自己写，我这里就贴一个样例，目录啥的都是上面提到的

1
2
3
4
5
6
7

server {
    listen  80;
    server_name your.server.name;
    location / {
        root    /home/git/project/blog;
    }
}

这种最简单的就可以了

当然如果你是像我这样用http的话就得稍微改一改，还得把80重定向到443
这种设置如果你用到了不会的话就自行百度吧～

本地测试hexo博客后上传部署

这就是最后啦，每次写完博文或者修改之后，先在本地工程目录下跑一下服务

1

hexo s -p 端口号

然后打开浏览器查看测试的博客页面

没有问题的话就可以生成静态资源了，当然先清除掉public目录下已有的静态资源文件

1
2

hexo clean
hexo g

这之后你可以使用这个命令测试

1

hexo s -s -p 端口号

多加一个-s表示只用静态资源跑服务器测试，测试一下静态资源的生成，同样打开浏览器查看网站

现在确认无误之后就要把静态资源上传部署到服务器了

1

hexo d

不报错的话说明没有问题啦，大功告成

今天才把物理机上的Ubuntu升到了18.04，原因有很大一部分是因为不想去鼓捣桌面界面之类的，毕竟Ubuntu从18.04开始，桌面程序放弃了unity而回归了Gnome～～美化是一定要美化的，毕竟这是自己电脑里用作图形桌面的，又不是要做server，要看的东西当然要赏心悦目啦。

写在前面

首先先看看美化后的桌面效果，这里用的是仿Mac的Mojave-dark主题

由于ubuntu回归Gnome桌面，以下的美化过程也是针对Gnome3的，所以大部分的美化过程可以套用在其他系统的Gnome桌面上，可能主题解压安装的目录会有些不同。
嘛，安装自己慢慢鼓捣就好，上网搜一搜，毕竟用的都是别人写的设计的主题。

美化资源下载网站等介绍

资源网站介绍

Gnome的外观主题等资源网站： https://www.gnome-look.org/
这个网站里包含了Gnome桌面的各种外观资源，网站左侧分类栏里可以看到如GTK3、GTK2的系统主题，图标icon主题，grub主题，Plymouth开机画面主题、GDM (GNOME Display Manager,用户登录界面，显示管理器)主题 乃至鼠标主题等

下载外观资源

GTK3桌面主题

在左侧分类栏选择想要下载的外观资源，首先是桌面主题，选择GTK3的主题（GTK3 Themes），然后会列出所有的GTK3主题，列表默认是Latest最新，点击Score按评分列出。

那写这篇的这个时间里名为【McMojave】的GTK3主题评分最高，当然我安装的也就是这个主题，以下也是描述安装这个主题，当然如果你想安装其他的主题也都是一样的步骤。
这边点进你想要安装的主题的详细信息页面，可以看到作者对主题的描述等，下面还有作者推荐的图标主题(icon theme)，这里点击【file】进入下载主题文件的页面

这里有很多文件，不需要全部下载，下载需要的或者想要的就可以了。我下载了【Mojave-dark.tar.xz】和【Mojave-light.tar.xz】也就是暗色和亮色主题。这里的solid指的是非透明主题，至于alt是什么意思我也不清楚。。。而我在前言里的图片就是它的暗色主题啦。

图标主题资源

那到这里桌面主题就下载完成了，现在还需要去下载图标主题资源
像McMojave这个主题在详情页推荐了它对应的图标主题，我们直接点进去，在【file】里下载就可以了，同样有很多文件，我们只下载想要的就可以了。
那如果有的主题没有推荐的图标或者并不想用对应主题的推荐图标，我们也可以在Gnome-look网站左侧栏点击【Icon Themes】,找到自己心仪的图标主题，过程和之前描述的GTK3主题如出一辙，我就不多赘述了

其他主题资源

那如果你需要下载其他的主题资源，譬如grub主题，Plymouth开机画面主题、GDM (GNOME Display Manager,用户登录界面，显示管理器)主题、Cursors鼠标主题等，下载过程也是跟上面描述的GTK3桌面主题一样

桌面系统美化

主题资源安装（解压）

将资源文件解压到对应的目录中
其中桌面主题解压到/usr/share/themes/目录下
图标主题或鼠标主题解压到/usr/share/icons/目录下
桌面/锁屏背景图放到/usr/share/backgrounds/目录下

主题配置工具安装

主题配置需要「gnome-tweak-tool」

1
2

sudo apt-get install gnome-tweak-tool
sudo apt-get install gnome-shell-extensions

shell拓展安装

这里推荐用火狐浏览器插件安装拓展

1. 打开你的Firefox火狐浏览器，打开https://extensions.gnome.org/
2. 网页提示需要完成安装浏览器插件和本地应用两步
   直接点click here to install brower extension安装浏览器插件
3. 然后终端输入命令安装本地软件

   1	sudo apt install chrome-gnome-shell

4. 安装完后打开https://extensions.gnome.org/extension/19/user-themes/安装user-themes拓展

这边安装拓展的方式很简单，在user-themes的右边可以看到一个按钮。不需要在下面选择版本，直接点击按钮拨到「on」，过一会儿会弹出一个弹窗提示你是否安装，点安装即可。

在这个网站里你还可以通过这种方式安装其他的拓展，建议安装
「Dash to Dock」、「Hide Top Bar」、「Simple net speed」这几个拓展

当然除了通过火狐浏览器插件安装拓展以外，也可以通过软件包管理来安装，这里不做描述了。

桌面美化过程

• 打开gnome-tweak-tool（优化），选择拓展，打开User themes （这里上一条通过火狐浏览器安装拓展已经打开的话就可以忽略这条）
• 选择外观，进行设置
  这里【应用程序】指的是安装的GTK3的主题，光标指的是cursor鼠标主题，图标即icon主题，shell选择主题对应的即可；至于下面锁屏和背景的图像，选择自己复制在background目录下的图片即可
  如果shell上有感叹号，关闭tweak，按Alt+F2，输入r，执行后重新打开tweak再设置shell选项。
  
• 调整标题栏按钮位置
  选择【窗口】，滑到最下面，将【放置】改为左
• 调整Dock，使用Dash to Dock拓展
  选择【拓展】，开启【Dash to Dock】，点击设置图标(小齿轮)，然后按下图设置
  

开关机启动动画美化

• 首先还是下载启动动画主题
  还是在gnome-look网站里，左侧栏选择【Plymouth Themes】找到你想要的主题
  那我这里选择的是Paw Ubuntu/Mint Floral

这位MARKOSPOKO还有不少不错的ubuntu Plymouth开关机主题，可以看一看选择一下

• 将下载下来的主题压缩包解压，将解压下来的主题目录复制到/usr/share/plymouth/themes/目录
• 备份原来的plymouth配置文件并编辑修改

  1 2	sudo cp /etc/alternatives/default.plymouth /etc/alternatives/default.plymouth.bak sudo vim /etc/alternatives/default.plymouth

• 最后将default.plymouth文件的最后两行按下图方式修改，注意修改的主题目录和自己下载复制的匹配，最后的script文件要自己去主题目录下ls看一下script文件名是什么。
  

登录界面GDM（显示管理器）主题美化

• 还是在gnome-look网站里，左侧栏选择【GDM Themes】找到你想要的主题 下载
  我这里演示的是仿Mac的High Ubunterra，我也比较推荐这个。
  打开High Ubunterra的详细描述页面，下面很详细的介绍了注意事项和安装方式，包括不同版本的Ubuntu应该下载不同的版本，还分为有密码和无密码两种
  那我这里是Ubuntu18.04，于是我下载的是【High_Ubunterra_2.3(Pass).tar.xz】
• 将下载下来的压缩文件解压，按照主题的详细页面所描述的，使用install.sh脚本直接安装即可
  
  然后根据终端提示的，按Alt+F2，输入r，执行后再按Win+L进入锁屏查看效果

  emm……本来应该是这样就可以了，但是实际上进入锁屏界面却发现情况有点不对，界面的背景图片没有了
  于是我们查看 /etc/alternatives/gdm3.css文件里的lockDialogGroup类，发现背景图片指向/usr/share/backgrounds/gdmlock.jpg
  
  但是在/usr/share/backgrounds/目录下ls并未发现gdmlock.jpg图片文件
  于是问题找到了，也好解决
  只需要将背景图复制到/usr/share/backgrounds/gdmlock.jpg 即可，或者修改/etc/alternatives/gdm3.css文件，但更推荐复制背景图

grub 美化

• 还是在gnome-look网站里，左侧栏选择【GRUB Themes】找到你想要的主题 下载
  我这里演示的是Vimix主题
• 这个主题的安装方式也是很简单粗暴，解压后在里面打开终端，使用install.sh脚本安装即可

  1	sudo ./install.sh

终端美化

gnome-terminal的配置

terminal的美化过程很简单，Ctrl+Alt+T打开终端

• 选择【编辑】-> 【首选项】-> 【常规】，将第一项【默认在新终端中显示菜单栏】的勾去掉
• 然后点击下面的配置文件进行修改，将【使用系统主题的透明度】的勾去掉，再把【使用透明背景】勾上，在右边调整透明度
  透明度不要太高，太透明就不好看清字了，稍微透明一点就可以了

  shell(zsh)

推荐放弃bash，使用zsh配合oh-my-zsh起飞

安装zsh与oh-my-zsh

• 首先安装「zsh」 「git 」「curl 」

  1	sudo apt-get install zsh git curl

• 然后根据oh-my-zsh官网的安装脚本进行安装
  • 通过curl安装
  • 通过wget安装

  sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

  sh -c "$(wget https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh -O -)"

安装过程中会询问是否切换默认shell为zsh，记得选“Y”

当然如果不能通过脚本直接安装oh-my-zsh的情况下，官方文档里也有手动安装的过程教程https://github.com/robbyrussell/oh-my-zsh#manual-installation

更改oh-my-zsh主题

更改oh-my-zsh主题需要修改zsh的配置

1

vim ~/.zshrc

在11行左右会有「ZSH_THEME」变量，也就是oh-my-zsh主题了，默认是robbyrussell，你可以去搜一搜有哪些好看的自带主题，修改这一变量的值为主题名即可
我这里提几个我常用的，「ys」「agnoster」「amuse」「candy」
当然你也可以写「random」，每次打开终端都会随机选择一个主题呈现，也挺有趣的
当然也可以选择几个固定的主题，每次在这些主题中随机，你只需要将ZSH_THEME变量修改random之后，将下面的ZSH_THEME_RANDOM_CANDIDATES变量的#注释去掉，并像这样修改即可

1
2
3
4
5

ZSH_THEME_RANDOM_CANDIDATES=(
  "robbyrussell"
  "agnoster"
   "ys"
)

powerline字体安装

oh-my-zsh的许多主题需要powerline字体支持
ubuntu可以直接通过apt安装

1

sudo apt-get install fonts-powerline

这时重启终端，像agnoster这样的主题应该就不会乱码了

Nginx 无疑是我最最常用的Web Server。就我多年使用的经验来说，这玩意的安装方式(Linux)，最最好还是编译安装
虽然不如软件包管理来的方便，但是万一哪天你想装个插件写个插件啥的你就哭去吧，等着你卸载重装
另外就是软件包管理的nginx版本，有的可以老出几个世纪（笑）
编译安装的话在这方面就灵活的多啦～～～

当然今天突然想起来写这篇还是因为之前腾讯云阿里云的学生认证到期了，得重新买了，当然这边环境也就重新搭，顺便写一下
（话说这个安装脚本一直都是记在OneNote上的，哪天心情好把记在OneNote里的东西都转到博客上来呢，，hh我还是太懒）

依赖安装

编译安装nginx前需要解决两个问题

1. 编译所需的编译器等软件，比如gcc，make之类的

2. 第三方依赖包，安装nginx的第三方依赖一般是这三个

   • pcre库（支持rewrite模块）『一个Perl库，包括 Perl兼容的正则表达式库』

   • zlib库（支持gzip模块）『提供数据压缩用的函式库』

   • openssl库（支持ssl模块）『一个强大的安全套接字层密码库』

     那这些库就完全没有必要编译安装了，一般的linux发行版直接用软件包管理安装即可

下面就贴出软件包管理安装这些依赖的命令

configure脚本

废话也不多说了，直接上脚本，会用的直接拿去，不用听我在下面解释了～～～

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

./configure --prefix=/usr/local/nginx \
--sbin-path=/usr/sbin/nginx \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--pid-path=/var/run/nginx/nginx.pid \
--lock-path=/var/run/nginx.lock \
--with-http_ssl_module \
--user=nginx \
--group=nginx \
--http-log-path=/var/log/nginx/access.log \
--http-client-body-temp-path=/var/cache/nginx/client_temp \
--http-proxy-temp-path=/var/cache/nginx/proxy_temp \
--http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp \
--http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp \
--http-scgi-temp-path=/var/cache/nginx/scgi_temp \
--with-http_sub_module \
--with-http_realip_module \
--with-http_dav_module \
--with-http_mp4_module \
--with-http_flv_module \
--with-http_gzip_static_module \
--with-http_gunzip_module \
--with-http_stub_status_module \
--with-http_random_index_module \
--with-http_secure_link_module \
--with-http_auth_request_module \
--with-mail \
--with-mail_ssl_module \
--with-file-aio \
--with-threads \
--with-stream_ssl_module \
--with-http_slice_module \
--with-http_v2_module

这是我每次编译安装nginx都会用到的选项配置（虽然里面有很多选项都是默认配置，不过列出来方便修改也直观），我基本上除了外加的nginx插件配置，其他的安装配置都在这里面了

添加第三方Nginx插件

Nginx能够添加许多第三方插件，但是大部分都需要编译安装添加
这里我以nginx-http-flv-module模块举例

nginx-http-flv-module是一个基于nginx-rtmp-module的流媒体服务器
因为以前用nginx搭过直播服务器，机缘巧合了解的

• 首先下载该模块源码，解压到nginx的源码包根目录(推荐)，将模块源码目录名改成nginx-http-flv-module
• 修改上面的脚本，添加下面的代码

  1	--add-module=nginx-http-flv-module

  这里如果你没有把解压的模块源码包放在nginx包根目录也没有改名，那么在--add-module=后面写它的绝对路径 或者 于nginx包的相对路径
• 之后按下面的继续编译安装即可

configure脚本使用

嘛这个使用起来很简单的嘞，先把nginx官网下载的源码包解压了，然后进入到源码包根目录，新建一个sh文件，那我这里一般就简单粗暴的叫c.sh，然后把上面的脚本粘进去保存。
记得给c.sh执行权限，之后执行这个脚本就可以了

1
2

chmod +x c.sh
./c.sh

编译安装

至于编译安装的过程就不赘述了，configure之后就是make加make install三步走就完了，不报错就行了
make install因为上面脚本配置上涉及写入文件到一些需要root权限的目录，非root用户记得加sudo

1
2

make
sudo make install

安装完之后使用nginx命令启动不报错即可，如果需要停止nginx，使用nginx -s stop，修改配置后重新启动使用nginx -s reload

常见报错

nginx: [emerg] getpwnam(“nginx”) failed

出现原因是因为编译配置指定了启动的用户和用户组：--user=nginx 和 --group=nginx
然而系统内并没有该用户和用户组以启动导致的报错
解决方案无非两种：

1. 将编译配置中的指定用户和用户组的两行配置去掉，重新编译安装
2. 新建该用户 sudo useradd -s /sbin/nologin -M nginx

虽然两种都可以，但一般更建议使用第二种
因为出于安全性考虑，还是用独立权限的账户运行更安全

nginx: [emerg] mkdir() “/var/cache/nginx/client_temp” failed (2: No such file or directory)

那这种一看就知道是权限问题，无法创建目录
因为指定了的启动用户没有权限在该目录下创建文件或目录的类似报错
解决方法很简单直接sudo或切root手动创建目录
mkdir -p /var/cache/nginx/client_temp

内网穿透

即NAT穿透，本质上是通过映射端口，使得内网的网络服务可以被外网所访问
嘛，，实际意义就是，大家家里的网络都是运营商分配的ip，并不是外网ip，无法直接用家里的电脑/服务器提供网络服务，譬如网站等
通过内网穿透即可将内网中你所提供的网络服务的端口映射到外网某ip的某端口，即可实现通过被映射的外网端口访问到内网服务
一般有很多提供这种服务的服务商譬如花生壳等，也有很多人知道一些譬如Ngrok的服务，而这里我所要描述的是一款名为frp的应用

what is the 「frp」

frp 是一个可用于内网穿透的高性能的反向代理应用，支持 tcp, udp, http, https 协议。

来自文档描述
frp项目github地址

话说了解frp的契机嘛，就是MinecraftServer了
腾讯云阿里云等的小基础配置根本带不动现在越来越卡优化越来越差游戏版本了，也买不起更高配置的VPS了，当然是用自己的电脑开最经济。那就得解决内网问题了。正好不知道在哪儿看到了SakuraFrp的宣传，那与其用公用的那当然不如自建啦。
当然这玩意的用处不只是搭游戏服务器，无论是网站还是什么服务基本上都可以，大部分的网络通信协议都支持，只不过就普通的网站之类的服务，vps的基础配置也绰绰有余了，犯不着用这玩意在自己家搭，，不过话说回来，搭个NAS啊监控啊之类的还是用得着的恩恩。

frps (server) 部署配置

首先是服务端，那做内网穿透的话，服务端当然是建在有公网ip的远程服务器上。 （服务端机器相当于是服务提供者和服务访问者中间的桥梁）
先在Frp官网(github)上下载下来的对应系统的frp程序包，解压后可以看到frp的服务端、客户端的程序和配置文件。
因为这里是做服务端，可以先把客户端相关的东西删了（当然不删也无所谓）。在frp目录下执行：

1

rm ./frpc*

现在就该修改配置文件了

frpc (client) 配置

现在轮到客户端了。
不过提一下，这里的客户端指的是提供想要被外网访问的服务的内网机器。
提这一句的原因是，frp的客户端还有一种用法，是在stcp这种安全访问的服务上，或者是xtcp这种p2p连接服务上，客户端需要同时设置在内网服务和访问者两端，当然这种情况我这篇博文不会展开描述，有兴趣欢迎去看官方文档

其实并不常做字幕特效，毕竟也基本上都是心血来潮自己完成全部的字幕任务，不过每次想做的时候总是记不住那些特效代码，翻帖子去找然后慢慢试效果，果然还是自己整理一个较常用的标签列表比较妥当

先贴一个完整的标签代码手册

基本规则

• 形如{\代码名1(值)\代码名2\代码名3值}的用大括号{}括起的即为生效的一块代码组，每个代码前必须有反斜杠*，小括号不是必须（看相应代码是否需要，值可如坐标，持续时间等），上例为三个代码组成的一组，因为代码前都有反斜杠，可以通过反斜杠来区分组内的每个代码，而代码1需要小括号和值，代码2不需要值，代码3后面直接加值不需要小括号
• 反之，括号外的即字幕内容，如果大括号{}外出现了带反斜杠\的代码，不用怀疑，那肯定不是特效代码，十有八九是转义字符，譬如\N即为换行，\h为空格
• 若行内出现了被若干组代码，切记代码会对在其后的所有文字生效，而特性相同值不同的代码会被后面的代码覆盖

代码整理

基本效果

1. pos 位置，没什么好说的，动一下就会有，然后xy微调即可
   (0,0)为左上顶点，向右x正方向，向下y正方向

2. fad 淡入淡出
   如\fad(100,150)100和150分别是开始和结束时间，单位嘛，这里的1000毫秒是1秒
   再如\fad(100,0)指渐渐出现直接消失，\fad(0,100)是直接出现渐渐消失

3. move 位移
   {\move(X1,Y1,X2,Y2,t1,t2)}，即字幕从(X1,Y1)的位置在本字幕始的t1毫秒到t2毫秒，以均速平滑移动到(X2,Y2)
   t1,t2可省略，默认为整行字幕的时间

4. blur 边缘柔化/模糊
   如\blur1，blur后直接跟模糊值，不必小括号

5. bord 边框宽度
   如\bord1，bord后直接跟宽度值，不必小括号

6. fs 即font size,字体大小
   \fs10即字体大小设置为10，注意这里的值必须是整数

7. fsp 即font spacing字符间距，间距可以为负

8. frx,fry,frz 文本旋转 font rotate
   \frx45把文本沿 X 轴方向旋转45度
   \fry-45把文本沿 Y 轴反方向旋转45度
   \frz180把文本沿 Z 轴旋转180度，即上下翻转

9. fscx,fscy 即Font scale字体在x或y轴上缩放
   \fscx150字体比正常的宽50%
   \fscy50字体比正常的矮50%
   \fscx200\fscy200字体大小变成正常的两倍

10. 设置颜色
    \c&H<bb><gg><rr>& 为1c的缩写。。。。
    \1c&H<bb><gg><rr>& 设置主要填充颜色
    \2c&H<bb><gg><rr>& 设置次要填充颜色
    \3c&H<bb><gg><rr>& 设置边框颜色
    \4c&H<bb><gg><rr>& 设置阴影颜色
    颜色代码要以十六进制填写，顺序是蓝、绿、红。注意这个顺序和 WEB颜色的顺序是相反的。颜色代码必须以&H开头，以&结尾。

11. 设置透明度
    \alpha&H<aa> 一次设置以下4个部分的透明度。
    \1a&H<aa> 设置主要填充透明度。
    \2a&H<aa> 设置次要填充透明度
    \3a&H<aa> 设置边框透明度。
    \4a&H<aa> 设置阴影透明度。
    alpha 值为00意味着完全不透明，而为FF（十进制的255）即为完全透明。

t渐变的动画效果（重要）

\t(t1,t2,速度,特效标签) 其中t1,t2和速度可省略

自动化相关

1. \k 即karaoke
2. \r 重置样式，重置其后字符的样式，会让一切样式标签失效，包括动画效果

来源于大一数据结构上机课程的练习，最近复习数据结构时候做个备份吧感觉当时写的还算很有心
有时间慢慢整理吧~

标注OOP的话就是cpp面向对象实现的，没有的话就是普通的结构体
所有的structure实现都是头文件.h和.cpp实现操作，具体的测试main函数就不放出了，自行测试

顺序表实现

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

//sqlist.h
#ifndef SQLIST
#define SQLIST
#define MaxSize 50
typedef char ElemType;
typedef struct {
ElemType data[MaxSize];
int length;
} SqList; /**
*
*
*
**/
void InitList(SqList * &L); //初始化顺序表
void CreateList(SqList * &L, ElemType a[], int n); //采用尾插法依次插入元素
void DispList(SqList *L); //打印线性表
int ListLength(SqList *L); //求线性表长度
bool isEmptyList(SqList *L); //判断线性表是否为空表(空表则返回true)
bool GetElem(SqList *L, int n, ElemType &e); //求线性表某位置的元素值,求得的值返回给e
int LocateElem(SqList *L, ElemType e); //求某值在线性表中的位置
bool InsertList(SqList * &L, ElemType e, int n); //在线性表某位置插入元素
bool DeleteElem(SqList * &L, int n); //删除线性表中某位置元素
void DestroyList(SqList * &L); //释放线性表
#endif

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

//sqlist.cpp
#include "sqlist.h"
#include <iostream>
#include <cstdlib>
void InitList(SqList * &L)
{
L = (SqList *) malloc(sizeof(SqList));
L->length = 0;
}

void CreateList(SqList * &L, ElemType a[], int n)
{
for(int i = 0;i < n; i++) {
L->data[i] = *(a+i);
}
L->length = n;
}

void DispList(SqList *L)
{
for (int i = 0; i < L->length; i++) {
std::cout<< i+1 <<". "<<L->data[i]<<"\n";
}
std::cout<<"Finished!"<<std::endl;
}

int ListLength(SqList *L)
{
return L->length;
}

bool isEmptyList(SqList *L)
{
return (L->length == 0);
}

bool GetElem(SqList *L, int n, ElemType &e)
{
if (n < 1 || L->length < n) return false;
else e = L->data[--n];
return true;
}

int LocateElem(SqList *L, ElemType e)
{
int i = 0;
while(i < L->length && e != L->data[i]) i++;
if (i >= L->length) return 0;
else return i+1;
}

bool InsertList(SqList * &L, ElemType e, int n)
{
if (n < 1 || L->length+1 < n) return false;
n--;
for(int j = L->length; j > n; j--) 
L->data[j] = L->data[j-1];
L->data[n] = e;
L->length++;
return true;
}

bool DeleteElem(SqList * &L, int n)
{
if (n < 1 || L->length < n) return false;
n--;
for(int j = n; j < L->length-1; j++) 
L->data[j] = L->data[j+1];
L->length--;
return true;
}

void DestroyList(SqList * &L)
{
free(L);
}

[OOP]队列ADT顺序表实现(非循环)

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

//SequenceQueue.h
#ifndef SEQUENCEQUEUE
#define SEQUENCEQUEUE

typedef char ElemType;
class SqQueue { /**
  *
  *[面向对象实现]队列ADT(顺序表实现)(非循环)
  *
  **/
private:
  ElemType *data;
  int front;
  int rear;
public:
  SqQueue();
  ~SqQueue();
  bool isEmptyQueue();
  void TraverseQueue();
  int QueueLength();
  bool GetFront(ElemType &e);
  bool EnQueue(ElemType e);
  bool DeQueue(ElemType &e);
  void CreateQueue();
};

#endif

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

//SequenceQueue.cpp
#include "SequenceQueue.h"
#include <iostream>
using namespace std;
const int MaxSize = 50;

SqQueue::SqQueue() //构造函数
{
  data = new ElemType[MaxSize];
  front = rear = -1;
}

SqQueue::~SqQueue() //析构函数
{
  delete []data;
}

bool SqQueue::isEmptyQueue()
{
  return front == rear;
}

void SqQueue::TraverseQueue()
{
  if (this->isEmptyQueue()) {
    cout << "==-> Queue is empty. <-==" << endl;
    return ;
  }
  std::cout << "\n==-- Now print the elements of the queue. --==\n";
int n = 1;
for (int i = front + 1; i != rear + 1; i++) {
cout << n << ". " << *(data + i) << "\t";
if (n%5 == 0) std::cout << "\n";
n++;
} std::cout << "\n-- Traversal Print Finished! --" << std::endl;
return ;
}

int SqQueue::QueueLength()
{
  return rear - front;
}

bool SqQueue::GetFront(ElemType &e)
{
  if (this->isEmptyQueue()) {
    cout << "\n==-> ERROR. Queue is empty. <-==" << endl;
    return false;
  }
  e = *(data + front + 1);
  return true;
}

bool SqQueue::EnQueue(ElemType e)
{
  if (rear + 1 == MaxSize) { //队列满，上溢
cout << "\n==-> ERROR.. Queue is full. <-==" << endl;
return false;
}
  rear++;
  *(data + rear) = e;
  return true;
}

bool SqQueue::DeQueue(ElemType &e)
{
  if (this->isEmptyQueue()) {
    cout << "\n==-> ERROR. Queue is empty. <-==" << endl;
    return false;
  }
  front++;
  e = *(data + front);
  return true;
}

void SqQueue::CreateQueue()
{
  if (data == NULL) {
  cout << "\n==-- ERROR.Pointer is NULL --==" << endl;
  return ;
}
ElemType tmp;
cout << "\n  ========Now input the data of the Queue========\n";
  cout<<"--If you want to finish inputing, please input \"#\"--\n";
  cout << "1. ";
  cin >> tmp;
for(int i = 2; tmp != '#'; i++) { //结束标志为‘#’
  if (!this->EnQueue(tmp)) {
  break;
  }
  cout << i << ". ";
cin >> tmp;
  }
cout << "\n==--< Finished input! >--==" << endl;
}

队列ADT顺序表实现(循环)

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

//SequenceQueue.h
#ifndef SEQUENCEQUEUE
#define SEQUENCEQUEUE

typedef char ElemType;
typedef struct List SqQueue, *ptrSqQueue; /**
 *
 *队列ADT(顺序表实现)(循环)
 *
 **/

void InitQueue(ptrSqQueue &Q); //初始化队列，为队列分配内存，建立空队列
void FreeQueue(ptrSqQueue &Q); //释放队列内存
bool isEmptyQueue(ptrSqQueue Q); //判断队列是否为空，空则返回true
void TraverseQueue(ptrSqQueue Q); //遍历打印队列元素
int QueueLength(ptrSqQueue Q); //返回队列元素的个数
bool GetFront(ptrSqQueue Q, ElemType &e); //取队头元素，返回给e
bool EnQueue(ptrSqQueue Q, ElemType e); //入队
bool DeQueue(ptrSqQueue Q, ElemType &e); //出队，删除的队头元素返回给e
void CreateQueue(ptrSqQueue Q); //交互式创建队列元素

#endif

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
102

//SequenceQueue.cpp
#include <iostream>
#include <cstdlib>
#include "SequenceQueue.h"
#define MaxSize 50

struct List {
ElemType data[MaxSize];
int front; //队头指针
int rear; //队尾指针
};

void InitQueue(ptrSqQueue &Q) //初始化队列，为队列分配内存，建立空队列
{
Q = (ptrSqQueue)malloc(sizeof(SqQueue));
Q->front = Q->rear = 0;
}

void FreeQueue(ptrSqQueue &Q) //释放队列内存
{
free(Q);
}

bool isEmptyQueue(ptrSqQueue Q) //判断队列是否为空，空则返回true
{
return Q->rear == Q->front;
}

void TraverseQueue(ptrSqQueue Q) //遍历打印队列元素
{
if (isEmptyQueue(Q)) {
std::cout << "==-> Queue is empty. <-==" << std::endl;
    return ;
  }
std::cout << "\n==-- Now print the elements of the queue. --==\n";
int n = 1;
for (int i = (Q->front + 1) % MaxSize; i != Q->rear + 1; ) {
std::cout << n << ". " << Q->data[i] << "\t";
if (n%5 == 0) std::cout << "\n";
n++;
i = (i + 1) % MaxSize;
} std::cout << "\n-- Traversal Print Finished! --" << std::endl;
return ;
}

int QueueLength(ptrSqQueue Q) //返回队列元素的个数
{
return (Q->rear - Q->front + MaxSize) % MaxSize;
}

bool GetFront(ptrSqQueue Q, ElemType &e) //取队头元素，返回给e
{
if (isEmptyQueue(Q)) {
std::cout << "\n==-> ERROR.. Queue is empty. <-==" << std::endl;
    return false;
  }
e = Q->data[(Q->front+1)%MaxSize];
return true;
}

bool EnQueue(ptrSqQueue Q, ElemType e) //入队
{
if ((Q->rear+1)%MaxSize == Q->front) { //队列满，上溢
std::cout << "\n==-> ERROR.. Queue is full. <-==" << std::endl;
return false;
}
Q->rear = (Q->rear + 1) % MaxSize;
Q->data[Q->rear] = e;
return true;
}

bool DeQueue(ptrSqQueue Q, ElemType &e) //出队，删除的队头元素返回给e
{
if (isEmptyQueue(Q)) {
std::cout << "\n==-> ERROR.. Queue is empty. <-==" << std::endl;
    return false;
  }
Q->front = (Q->front + 1) % MaxSize;
e = Q->data[Q->front];
return true;
}

void CreateQueue(ptrSqQueue Q) //交互式创建队列元素
{
if (Q == NULL) {
  std::cout<<"\n==-- ERROR.Pointer is NULL --=="<<std::endl;
  return;
}
ElemType tmp;
std::cout << "\n  ========Now input the data of the STACK========\n";
  std::cout<<"--If you want to finish inputing, please input \"#\"--\n";
  std::cout << "1. ";
  std::cin >> tmp;
for(int i = 2; tmp != '#'; i++) { //结束标志为‘#’
  if (!EnQueue(Q, tmp)) {
  break;
  }
  std::cout << i << ". ";
std::cin >> tmp;
  }
std::cout << "\n==--< Finished input! >--==" << std::endl;
}

队列ADT链表实现

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

//LinkQueue.h
#ifndef LINKQUEUE
#define LINKQUEUE

typedef char ElemType;
typedef struct node QueueNode, *ptrQueueNode;
typedef struct ptr_of_queue LinkQueue, *ptrLinkQueue;/**
 *
 *队列ADT(链表实现)
 *
 **/
void InitQueue(ptrLinkQueue &Q); //初始化队列，为队列指针分配内存，建立空队
void FreeQueue(ptrLinkQueue &Q); //释放队列内存
bool isEmptyQueue(ptrLinkQueue Q); //判断队列是否为空，空则返回true
void TraverseQueue(ptrLinkQueue Q); //遍历打印队列元素
int QueueLength(ptrLinkQueue Q); //返回队列元素的个数
bool GetFront(ptrLinkQueue Q, ElemType &e); //取队头元素，返回给e
bool EnQueue(ptrLinkQueue Q, ElemType e); //入队
bool DeQueue(ptrLinkQueue Q, ElemType &e); //出队，删除的队头元素返回给e
void CreateQueue(ptrLinkQueue Q); //交互式创建队列元素

#endif

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//LinkQueue.cpp
#include <iostream>
#include <cstdlib>
#include "LinkQueue.h"

struct node {
ElemType data;
struct node *next;
};
struct ptr_of_queue {
ptrQueueNode front;
ptrQueueNode rear;
};

void InitQueue(ptrLinkQueue &Q) //初始化队列，为队列指针分配内存，建立空队
{
Q = (ptrLinkQueue)malloc(sizeof(LinkQueue));
Q->front = Q->rear = NULL;
}

void FreeQueue(ptrLinkQueue &Q) //释放队列内存
{
ptrQueueNode p = Q->front, r;
if (p != NULL) {
r = p->next;
while (r != NULL) {
free(p);
p = r; r = p->next;
}
}
free(p);
free(Q);
}

bool isEmptyQueue(ptrLinkQueue Q) //判断队列是否为空，空则返回true
{
return Q->rear == NULL;
}

void TraverseQueue(ptrLinkQueue Q) //遍历打印队列元素
{
ptrQueueNode p = Q->front;
if (p == NULL)
{
std::cout<<"\n==--> The Queue is Empty. <--=="<<std::endl;
return ;
}
std::cout<<"\n==-- Now print the elements of the QUEUE. --==\n";
int i = 1;
while (p!=NULL) {
std::cout<< i << ". " << p->data << "\t";
p = p->next;
if (i%5 == 0) std::cout<<"\n";
i++;
} std::cout << "\n-- Traversal Print Finished! --" << std::endl;
return ;
}

int QueueLength(ptrLinkQueue Q) //返回队列元素的个数
{
int l = 0;
ptrQueueNode p = Q->front;
while (p != NULL) {
l++;
p = p->next;
} return l;
}

bool GetFront(ptrLinkQueue Q, ElemType &e) //取队头元素，返回给e
{
if (isEmptyQueue(Q))
{
std::cout<<"==--< ERROR.Empty Queue. >--=="<<std::endl;
return false;
}
e = Q->front->data;
return true;
}

bool EnQueue(ptrLinkQueue Q, ElemType e) //入队
{
if (Q==NULL)
{
std::cout<<"--< ERROR!The pointer is NULL. >--"<<std::endl;
return false;
}
ptrQueueNode tmpNode;
tmpNode = (ptrQueueNode)malloc(sizeof(QueueNode));
tmpNode->data = e;
tmpNode->next = NULL;
if (isEmptyQueue(Q)) Q->front = Q->rear = tmpNode;
else {
Q->rear->next = tmpNode;
Q->rear = tmpNode;
}
return true;
}

bool DeQueue(ptrLinkQueue Q, ElemType &e) //出队，删除的队头元素返回给e
{
if (Q==NULL)
{
std::cout<<"--< ERROR!The pointer is NULL. >--"<<std::endl;
return false;
}
if (isEmptyQueue(Q))
{
std::cout<<"==--< ERROR.Empty Queue. >--=="<<std::endl;
return false;
}
ptrQueueNode t;
t = Q->front;
if (Q->front == Q->rear) Q->front = Q->rear = NULL;
else Q->front = t->next;
e = t->data;
free(t);
return true;
}

void CreateQueue(ptrLinkQueue Q) //交互式创建队列元素
{
if (Q==NULL)
{
std::cout<<"--< ERROR!The pointer is NULL. >--"<<std::endl;
return ;
}
ElemType tmp;
std::cout << "\n  ========Now input the data of the QUEUE========\n";
  std::cout<<"--If you want to finish inputing, please input \"#\"--\n";
  std::cout << "1. ";
  std::cin >> tmp;
for(int i = 2; tmp != '#'; i++) { //结束标志为‘#’
  if (!EnQueue(Q, tmp)) break;
  std::cout << i << ". ";
std::cin >> tmp;
 }
std::cout << "\n==--< Finished input! >--==" << std::endl;
}

学习koa框架时考虑到了一个问题，有关上传文件的实现
搜到了koa-multer这个可以直接用在koa的中间件，于是着手尝试食用

说说「伪分布式」

Hadoop的安装配置方式有三种：单机、伪分布式和完全分布式。

单机模式 顾名思义，只在一台单机上运行，不需要与其他节点交互，不使用HDFS分布式文件系统，不加载Hadoop的守护进程。当你解压了hadoop的软件包后的默认最小模式，各种配置为空。

完全分布式 需要在至少3台机器上配置hadoop节点，真正分布式地完成存储和计算任务。

伪分布式 也很好理解，即在单机上搭建分布式系统。虽然是在单机上运行，但是通过配置实现用不同的Java进程模仿分布式运行的各类节点，即在一个机器上，既有namenode也有datanode，既有jobtracker也有tasktracker。既然并没有在多台机器上真正的搭建分布式环境，所以称之为「伪分布式」。

安装环境

Hadoop需要安装在Linux环境下（当然macos也可以），无论是物理机linux或是虚拟机Linux均可，发行版本无所谓，我这里>使用的是ubuntu16.04 server,安装的Hadoop版本为2.8.1

创建用户与修改hostname

这一步对于伪分布式来说必要性不大，可以省略。如果是完全分布式的话还是有必要的。

创建新用户

假设创建一个名为“hadoop”的用户

1

useradd -m hadoop -s /bin/bash

这里稍微解释一下。-m 选项表示在创建用户的同时，新建该用户的主目录（例子中是/home/hadoop目录）；-s选项设置用户
登录的shell，例子中使用bash，如果你使用其他shell，如zsh则改为/bin/zsh
接着使用passwd命令更改hadoop用户密码

1

passwd hadoop

输两次密码即可（弱口令也可以，确认使用即可）

修改Hostname

修改存放主机名的hostname文件即可
需要注意的是，不同的linux发行版本，主机名的配置文件不同
ubuntu为 /etc/hostname 文件, centos为 /etc/sysconfig/network 文件
修改对应hostname字段即可

这里假设该主机的hostname为Master

jdk安装与配置

第一步. 安装

可以使用软件包管理安装openjdk

比如Debian系可以使用apt-get，redhat系可以使用yum，arch linux可以使用pacman,yaourt等前端
这里以ubuntu举例

1
2

sudo apt-get install openjdk-8-jre
sudo apt-get install openjdk-8-jdk

具体安装命令请移步链接http://openjdk.java.net/install/index.html

Oracle官网下载jdk安装

Java SE Downloads
在oracle官网里下载对应系统版本的jdk

第二步. 配置jdk环境变量

环境变量配置文件可以是/etc/profile 、 ~/.profile 、 ~/.bash_profile等其一均可
使用nano、vim等编辑器打开配置文件(注意sudo权限)，在文件末尾添加如下export配置

1
2
3
4

export JAVA_HOME=/usr/lib/java/jdk1.8.0_144
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin

注意你的JAVA_HOME的值要改成你所安装释放jdk的根目录（我这里将jdk安装在了/usr/lib/java目录下）
如果你是通过软件包管理安装openjdk 默认的安装根目录应该在/usr/lib/jvm/java-8-openjdk-adm64类似的目录位置，自己根据实际情况而变


编辑过profile配置文件之后需要通过.(点）命令或者source命令将配置应用到当前shell环境中

1

.   /etc/profile

1

source /etc/profile

结束后可以尝试执行java和javac命令，看看是否配置成功

SSH server密钥对登录配置 （所谓的免密登录）

这一步是为了集群所在主机的安全性。。。。。

好吧其实果然还是因为，免密登录会很方便啊，否则每次hadoop登录都要输密码，一输就是要输好几次，会疯的！ 不过安全性确实很重要~

安装ssh server（sshd）服务

因为大部分linux发行版，ssh client都是装好的,所以只需要安装server即可(执行一下ssh命令 如果提示找不到命令之类的错误那就是没有client啊~)

毋庸置疑使用软件包管理前端进行安装，这里同openjdk的安装，我使用的ubuntu使用apt-get命令安装openssh-server，其他的发行版本视自身情况而定。

1
2
3
4

 sudo apt-get install openssh-server

#如果没有client则执行以下命令安装openssh-client
 sudo apt-get install openssh-client

生成公私钥并配置免密登录

使用ssh-keygen命令生成密钥对

1
2
3

ssh-keygen -t rsa 
#或者
ssh-keygen -t dsa

之后一直回车（默认）即可


操作结束后会在~/.ssh目录下生成一对public-private key pair
id_rsa，id_rsa.pub或者id_dsa，id_dsa.pub ，前者私钥 后者公钥

接下来将pub公钥内容添加到被登陆主机的 ~/.ssh 目录即可
因为这里伪分布式是自己登录自己，所以直接改名为authorized_keys即可

1

cat id_dsa.pub >> ~/.ssh/authorized_keys

哦差点忘了 看看你公钥文件和.ssh目录的权限

1
2
3
4

#.ssh目录权限700
 chmod 700 -R ~/.ssh
#公钥列表文件600
 chmod 600 authorized_keys

此时使用

1

ssh localhost

Hadoop安装与配置

Hadoop的安装

Hadoop官网下载hadoop release binary包
将binary包解压到你所要安装hadoop的路径目录（本例将hadoop释放到/usr/local目录下）

1

sudo tar -zxvf hadoop-2.8.1.tar.gz -C /usr/local

建议将解压后的hadoop-2.8.1目录重命名为hadoop，以方便操作
解压完之后的hadoop命令已经可以使用,使用hadoop version命令查看当前hadoop版本

1

/usr/local/hadoop/bin/hadoop version

此时的Hadoop便是最小单机模式，因为并没有对节点等进行配置

在这里要将解压的hadoop目录的权限更改，更改所有者为当前用户，否则之后的一些操作可能会出现权限问题

1
2

cd /usr/local
sudo chown -R hadoop:hadoop hadoop

执行ls -l之后可以看到hadoop的目录变为了当前用户（本例中为hadoop用户）

为了方便使用hadoop等命令，建议将hadoop/bin目录添加到系统环境变量PATH中（过程同配置jdk环境变量）
配置系统配置文件（/etc/profile、/.bashrc、/.profile等均可）
添加下列语句

1
2

export HADOOP_HOME=/usr/local/hadoop
export PATH=$HADOOP_HOME/bin:$HADOOP_HOME

保存退出编辑器后使用.(点命令)或source命令将更改应用到当前shell

Hadoop集群配置（伪分布式）

我们需要配置hadoop的配置文件来搭建伪分布式环境
Hadoop的配置文件存放在hadoop/etc/hadoop/目录下

需要配置的配置文件如下

1. hadoop-env.sh
   在该配置文件中，建议修改其中JAVA_HOME项为jdk安装的绝对地址

2. core-site.xml
   在该配置文件中，主要需要配置两个配置项
   fs.defaultFS和hadoop.tmp.dir

   编辑器打开配置文件后会发现一对configuration标签，在该标签内添加如下配置

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

   <configuration> <!-- 从这里开始配置 --> <property> <name>fs.defaultFS</name> <value>hdfs://master:9000</value> </property> <property> <name>hadoop.tmp.dir</name> <value>file:/usr/local/hadoop/tmp</value> </property> <!-- 配置结束 --> </configuration>

   ---

   关于以下xml配置文件的配置说明
   下面的配置基本都是xml文件，配置项均配置在configuration标签内的property标签
   property标签内，配置项名称（键）括在name标签内，配置的值括在value标签内，具体如下

   1 2 3 4 5 6 7

   <configuration> <property> <name>###</name> <value>###</value> </property> </configuration>

   以下的配置项，基本的配置项会将xml直接贴出以供参考（复制）方便食用；其他的配置项会以name：value键值对的形式贴出，如有用到可以直接套进以上的“模板”食用

3. hdfs-site.xml

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

   <configuration> <!-- 从这里开始配置 --> <property> <name>dfs.namenode.secondary.http-address</name> <value>master:50090</value> </property> <property> <name>dfs.replication</name> <value>1</value> </property> <property> <name>dfs.namenode.name.dir</name> <value>file:/usr/local/hadoop/tmp/dfs/name</value> </property> <property> <name>dfs.datanode.data.dir</name> <value>file:/usr/local/hadoop/tmp/dfs/data</value> </property> <!-- 配置结束 --> </configuration>

4. mapred-site.xml (template)
   在目录下并无mapred-site.xml文件，但是奇怪的是有一个mapred-site.xml.template的模板？文件
   于是我们将mapred-site.xml.template复制成mapred-site.xml再在该文件内进行配置

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

   <configuration> <!-- 从这里开始配置 --> <property> <name>mapreduce.framework.name</name> <value>yarn</value> </property> <property> <name>mapreduce.jobhistory.address</name> <value>10020</value> </property> <property> <name>mapreduce.jobhistory.webapp.address</name> <value>19888</value> </property> <!-- 配置结束 --> </configuration>

5. yarn-site.xml

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

   <configuration> <!-- 从这里开始配置 --> <property> <name>yarn.resourcemanager.hostname</name> <value>Master</value> </property> <property> <name>yarn.nodemanager.aux-services</name> <value>mapreduce_shuffle</value> </property> <!-- 配置结束 --> </configuration>

6. slaves
   嘛，因为是伪分布式，这个就不需要配置了