CentOS 7 安装 Jenkins

2020-06-26 Dev

安装 Jenkins：

1
2
3
4
5
sudo wget -O /etc/yum.repos.d/jenkins.repo \
    https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key
sudo yum makecache
sudo yum install jenkins java-1.8.0-openjdk-devel

解决安装插件太慢的的问题：

1
2
3
cd /var/lib/jenkins/updates

sed -i 's/http:\/\/updates.jenkins-ci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

进行初始化安装，初始密码（也是 admin 密码）在 /var/lib/jenkins/secrets/initialAdminPassword：

1
http://ip:8080

go mod 支持私有仓库

2020-06-15 Dev

Go 1.13 设置 GOPRIVATE 环境变量：

1
export GOPRIVATE=gitlab.company.com

设置 git 默认为 ssh 而不是 https：

1
git config --global url."git@gitlab.company.com:".insteadOf "https://gitlab.company.com/"

CentOS 7 防火墙设置

2020-06-15 Dev 
1
2
3
4
5
6
7
8
9
10
11
sudo systemctl status firewalld
sudo firewall-cmd --state

sudo systemctl stop firewalld
sudo systemctl disable firewalld // 禁止开机自启

firewall-cmd --zone=public --add-port=5005/tcp --permanent
firewall-cmd --zone=public --query-port=80/tcp
firewall-cmd --zone=public --remove-port=80/tcp --permanent

firewall-cmd --reload

mysqldump 导出

2020-06-15 Dev 
1
2
3
4
5
6
7
8
9
10
11
// 从 dbname 库导出所有表结构及数据
mysqldump -u user -p dbname > db.sql;

// 从 dbname 库的 tblname 表导出表结构及数据
mysqldump -u user -p dbname tblname > db.sql;

// 从 dbname 库导出所有的表结构
mysqldump -u user -p -d dbname > db.sql;

// 从 dbname 库的 tblname 表导出表结构
mysqldump -u user -p -d dbname tblname > db.sql;

配置 Nginx 使其正确处理 PHP 请求

2020-06-12 Dev 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
server {
    listen       80;
    server_name  localhost;

    access_log  /var/log/nginx/access.log  main;

    root /path_to_code/public;
    index index.php index.html;

    location / {
        try_files $uri /index.php?query_string;
    }

    location ~ ^(.+\.php)(.*)$ {
        fastcgi_split_path_info ^(.+\.php)(.*)$;
        fastcgi_pass   127.0.0.1:9000;
        fastcgi_index  index.php;

        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        fastcgi_param  PATH_INFO        $fastcgi_path_info;
        include        fastcgi_params;
    }
}

参考：

在 CentOS 7 上编译安装 PHP 7.2

2020-06-05 Dev

配置阿里云源：

1
2
3
4
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

yum clean
yum makecache

安装依赖：

1
yum install gcc libxml2-devel openssl-devel

安装 PHP：

1
2
3
4
5
6
7
8
9
10
11
wget https://www.php.net/distributions/php-7.2.30.tar.gz

tar -zxf php-7.2.30.tar.gz
cd php-7.2.30

./configure --prefix=/usr/local/php72/ --enable-fpm --with-pdo-mysql --with-openssl --with-zlib --enable-mbstring --with-config-file-path=/usr/local/php72/etc/

make
make install

cp php.ini-development /usr/local/php72/etc/php.ini

MySQL 事务隔离整理

2020-05-07 Dev

事务

事务就是一组原子性的 SQL 操作，事务中的语句，要么全部执行成功，要么全部执行失败。

事务正确执行的四个要素（ACID）

  • 原子性（atomicity）
  • 一致性（consistency）
  • 隔离性（isolation）
  • 持久性（durability）

原子性

一个事务内的一组 SQL 语句被视为一个不可分割的单元，事务中的语句，要么全部执行成功，要么全部执行失败。

一致性

数据库总是从一个一致性的状态转移到另一个一致性的状态。

应用系统从一个正确的状态到另一个正确的状态，而 ACID 就是说事务能够通过 AID 来保证这个 C 的过程。C 是目的， AID 都是手段。

如何理解数据库事务中的一致性的概念？ - 孟波的回答 - 知乎 https://www.zhihu.com/question/31346392/answer/362597203

隔离性

“通常来说”，一个事务所做的修改在提交之前，对其他事务是不可见的。

持久性

事务一旦提交，其所做的修改就会保存到数据库中，此时即使系统崩溃，修改的数据也不会丢失。

Note: redo log 和 binlog

事务现象

执行事务时可能会出现三个特别的现象：

  • 脏读：一个事务可以读取到其他事务未提交的数据。
  • 不可重复读：一个事务内，执行两次相同的查询，得到的数据不一样。（特指列上的数据不一样）
  • 幻读：一个事务内，查询相同范围的数据，得到的记录数一样，这样产生幻影行的现象。

隔离级别

MySQL 支持四种隔离级别：

  • read uncommitted（读未提交）
  • read committed（读提交）
  • repeatable read（可重复读）
  • serializable（串行化）

read uncommitted（读未提交）

一个事务可以读取到其他事务未提交的数据。

read committed（读提交）

一个事务提交之前，所做的修改对其他事务不可见。但是由此会产生不可重复读的问题。

repeatable read（可重复读）

解决了不可重复读的问题，一个事务内，执行两次相同的查询，得到的数据一样。

通过多版本并发控制（MVCC）解决了幻读的问题。

rr 是 MySQL 的默认隔离级别。

serializable（串行化）

这个级别下，强制事务串行执行，会在读取的每一行数据上都加锁，所以可能导致大量的超时和锁争用的问题。

图片来自《高性能 MySQL》：

其他

查看隔离级别：

1
2
3
4
5
6
7
mysql> show global variables like '%tx_iso%';

+---------------+-----------------+
| Variable_name | Value           |
+---------------+-----------------+
| tx_isolation  | REPEATABLE-READ |
+---------------+-----------------+

设置隔离级别：

1
mysql> set transaction isolation level read committed;

支持事务的引擎：

  • InnoDB
  • NDB Cluster

多版本并发控制

MySQL 的事务型存储引擎基于并发性能的考虑实现了 MVCC。MVCC 是行级锁的一个变种，但是在很多情况下避免了加锁操作，开销更低。

MVCC 的实现，是通过保存数据在某个时间点的快照来实现的。

InnoDB 的 MVCC，是通过在每行记录后面保存两个隐藏的列来实现的。一个列保存了行的创建时间，另一个列保存行的过期时间（或删除时间）。不是具体的时间值，而是版本号。每开始一个新的事务，系统版本号会自动递增，事务开始时刻的系统版本号会作为事务的版本号，用来和查询到的每行记录的版本号进行比较。

MVCC 只在 repeatable read 和 read committed 隔离级别下工作。

Go range

2020-05-04 Dev 
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
func main() {
    users := []string{"alice", "bob", "claire"}

    for k, v := range users {
        fmt.Println(k, ":", v)
    }
    // 0 : alice
    // 1 : bob
    // 2 : claire

    for k := range users {
        fmt.Println(k)
    }
    // 0
    // 1
    // 2

    user := map[string]interface{}{
        "name": "alice",
        "age":  20,
    }

    for k, v := range user {
        fmt.Println(k, ":", v)
    }
    // name : alice
    // age : 20

    for k := range user {
        fmt.Println(k)
    }
    // age
    // name

    // 遍历 map 类型的值时，元素是随机的
  
    ch := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }()

    for c := range ch {
        fmt.Println(c)
    }
    // 0
    // 1
    // 2
    // 3
    // 4

获取整型数下标处的值

2020-04-24 Dev 
1
2
3
4
5
6
func getIntIndexValue(n, l, i int) int {
    if i >= l {
        panic(fmt.Sprintf("index should less than length,  index %d length %d", i, l))
    }
    return n / int(math.Pow10(i)) % 10
}