笔者有一台CentOS 7系统的Linux服务器，在通过ssh远程连接的时候，一直存在两个问题。
一是连通速度缓慢，ping服务器速度很快，但是SSH连接的响应非常慢。
再有就是连接一段时间，客户端这边如果没有操作和输入，服务器就会自动断开，每次都要重新连，很麻烦。

昨天晚上仔细检查了一下CentOS 7 sshd的配置，终于解决了这两个问题。其实很easy，修改CentOS默认的sshd配置就行了。

针对第一个ssh连接响应缓慢的问题，在/etc/passwd文件里这样配置就行了：

大概是在第129行的位置，找到UseDNS选项，取消前面的注释，将yes改为no即可：

1
2
3
4
5
6
7

127 #ClientAliveCountMax 3
128 #ShowPatchLevel no
129 UseDNS no
130 #PidFile /var/run/sshd.pid
131 #MaxStartups 10:30:100
132 #PermitTunnel no
133 #ChrootDirectory none

针对第二个连接超时timeout的问题，同样是修改sshd配置，大概在第126行的位置，找到选项ClientAliveInterval，将其值修改为30：

1
2
3
4
5
6

123 UsePrivilegeSeparation sandbox          # Default for new installations.
124 #PermitUserEnvironment no
125 #Compression delayed
126 ClientAliveInterval 30
127 #ClientAliveCountMax 3
128 #ShowPatchLevel no

这样ssh服务器就会每隔30秒判断一次客户端是否超时，由于30秒一般是不会超时的，所以连接就能持续。
而第127行的选项也可以关注一下，它代表的是最大的超时次数。

完美修复文章开头提到的两个问题。

Python 3 通过SMTP库发送普通邮件(Through SSL)

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

#!/usr/bin/python3

import smtplib
from email.header import Header
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart

mail_host = "smtp.chorder.net"
mail_port = 994
mail_user = "[email protected]"
mail_pass = "password"

sender_name = "Example"
sender_account = '[email protected]'
receivers = ['[email protected]']
receiver_name = "Somebody"

subject = 'Mail Subject'
mail_msg = '''
<h1>This is a test main</h1>
<p>Some text</p>
'''


msgRoot = MIMEMultipart('related')
msgRoot['From'] = Header(sender_name, 'utf-8')
msgRoot['To'] =  Header(receiver_name, 'utf-8')
msgRoot['Subject'] = Header(subject, 'utf-8')

msgAlternative = MIMEMultipart('alternative')
msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8'))

msgRoot.attach(msgAlternative)

try:
    smtpObj = smtplib.SMTP_SSL( mail_host, mail_port )
    #smtpObj.ehlo()
    #smtpObj.set_debuglevel(1)
    smtpObj.login( mail_user, mail_pass )
    smtpObj.sendmail(sender_account, receivers, msgRoot.as_string())
    print ("邮件发送成功")
except smtplib.SMTPException:
    print ("Error: 无法发送邮件")

Python 3 通过SMTP库发送带图片的邮件(Through SSL)

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

#!/usr/bin/python3

import smtplib
from email.header import Header
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart

mail_host = "smtp.chorder.net"
mail_port = 994
mail_user = "[email protected]"
mail_pass = "password"

sender_name = "Example"
sender_account = '[email protected]'
receivers = ['[email protected]']
receiver_name = "Somebody"


subject = 'Mail Subject'
mail_msg = '''
<h1>This is a test main</h1>
<p>Some text</p>
<h2>Image</h2>
<p><img src="cid:image1"></p>
'''

# add image attachment
fp = open('test.png', 'rb')
msgImage = MIMEImage(fp.read())
fp.close()

msgImage.add_header('Content-ID', '<image1>')

msgRoot = MIMEMultipart('related')

msgRoot['From'] = Header(sender_name, 'utf-8')
msgRoot['To'] =  Header(receiver_name, 'utf-8')
msgRoot['Subject'] = Header(subject, 'utf-8')

msgAlternative = MIMEMultipart('alternative')
msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8'))

msgRoot.attach(msgAlternative)
msgRoot.attach(msgImage)

try:
    smtpObj = smtplib.SMTP_SSL( mail_host, mail_port )
    #smtpObj.ehlo()
    #smtpObj.set_debuglevel(1)
    smtpObj.login( mail_user, mail_pass )
    smtpObj.sendmail(sender_account, receivers, msgRoot.as_string())
    print ("邮件发送成功")
except smtplib.SMTPException:
    print ("Error: 无法发送邮件")

Docker镜像仓库在国内访问速度巨慢无比，感谢DaoCloud公司提供的稳定加速
镜像，具体的配置方法如下：

1. 修改 /etc/docker 目录下的daemon.json

如果没有/etc/docker这个目录或者/etc/docker目录下没有daemon.json文件，手动创建即可。
将daemon.json的内容修改如下：

1
2
3

{
  "registry-mirrors": ["http://f1361db2.m.daocloud.io"]
}

2. 重启Docker服务

运行这两个命令：

1
2

systemctl daemon-reload
systemctl restart docker

Ruby有着便捷强大的Gem包管理机制，作为五十年后人类使用最多的编程语言，有必要提前普及一下Ruby Gem的编写制作教程，帮助大家更好的使用Ruby，使用Gem，最好也能让Ruby的Gem库更加丰富，社区能够更加活跃。那么如何从零开始制作和发布自己的Gem呢？一起来动手操作一下。

制作和发布Ruby Gem包一共分如下几个步骤：

1. 在RubyGems上注册帐号（如果你只想在本地或团队内部使用你的Gem，可以跳过这一步）
2. 编写和打包Gem(gem build xxx.gemspec)
3. 测试Gem(mang自mu信者可以跳过这一步)
4. 发布Gem(gem push xxx)

1. 注册RubyGems帐号

RubyGems.ORG 是一个大型的Gems仓库，你可以现在就加入它，贡献你的Gem。这一步想必无需多说，注册完成之后，你就拥有了属于自己的RubyGems帐号，别人就可以看到你的主页和你发布的Gems。

注册完成之后，你还需要将你的crendentials保存到本地，方便后续直接在命令行使用gem命令。运行

1

curl -u 你的用户名 https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials; chmod 0600 ~/.gem/credentials

2. 编写和打包Gem

编写Gem

我们这次要发布的Gem叫做template_chorder，你也可以改名成任意你想要的名字。首先我们创建一个工程目录，我的目录名叫做GemTemplate，其中包含如下内容：

其中，template.gemspec是项目的描述文件，gem build命令会基于这个文件进行打包。

template.gemspec内容如下：

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

Gem::Specification.new do |s|
  s.name        = 'template_chorder'
  s.version     = '0.0.0'
  s.date        = '2019-01-11'
  s.summary     = "Template!"
  s.description = "A simple template gem"
  s.authors     = ["Chorder"]
  s.email       = '[email protected]'
  s.files       = ["lib/template.rb"]
  s.homepage    = 'https://chorder.net/2019/01/11/rubygemtemplate/'
  s.license       = 'MIT'
end

其中s.name就是将来这个包发布出去的名字。默认的，我们需要将工程的主代码放在lib目录里面，这是ruby的约定。我们的Gem只包含一个很简单的功能，只需要放置全部代码在一个文件当中即可。

lib/template.rb的代码如下：

1
2
3
4
5

class Template
  def self.test
    puts "Hello, Ruby!"
  end 
end 

就是这么简单。

打包Gem

在工程的根目录，运行

1

gem build template.gemspec 

工程根目录将会产生一个 template_chorder-0.0.0.gem文件。
就是这么简单。

3. 测试Gem

对于刚刚生成的template_chorder-0.0.0.gem，运行

1

gem install template_chorder-0.0.0.gem

来安装它。

安装好以后，就可以在irb解释器中引入和运行它了。完整的过程如下：

疑问
这里其实是有点疑问的，就是为什么gem的名字叫做template_chorder，而在irb中引入的却是template。确实，如果gem包中的文件取名不严谨的话，可能会与其他包产生冲突。至于如何消除冲突，请君自己先思考下。

卸载Gem包，运行 gem uninstall template_chorder

2. 发布Gem

制作好这样一个不负责任的Gem包以后，就可以厚颜无耻地在RubyGems上发布它。但是为了社区的环境卫生清洁，尽量还是不要发布那些粗制滥造的包，就以此为戒吧。
发布Gem包，运行 gem push template_chorder-0.0.0.gem，如果第1步当中的帐号注册和保存
crendentials文件都没有问题，那么包就可以发布出去了。

本文的包发布在：https://rubygems.org/gems/template_chorder

希望能够对你有所帮助。

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

FROM debian
MAINTAINER Chorder
WORKDIR /root/
ADD sources.list /etc/apt/
ADD DVWA-master.zip /root/
ADD start.sh /root/
RUN apt-get update
RUN apt-get install -y mariadb-server mariadb-client php php-mysql php-gd zip net-tools
RUN unzip /root/DVWA-master.zip -d /var/www/
RUN rm -rf /etc/apache2/sites-enabled/000-default.conf
ADD dvwa.conf /etc/apache2/sites-enabled/
RUN cp /var/www/DVWA-master/config/config.inc.php.dist /var/www/DVWA-master/config/config.inc.php
RUN sed -i 's/'root'/dvwa/g' /var/www/DVWA-master/config/config.inc.php
RUN sed -i 's/^allow_url_include.*$/allow_url_include = On/g' /etc/php/7.0/apache2/php.ini
RUN chmod 777 -R /var/www/DVWA-master
RUN chmod +x /root/start.sh
ENTRYPOINT /root/start.sh && bash
EXPOSE 80

完整的项目下载：

多进程示例：

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

def test_proc(name,second)
  Process.setproctitle("PROC-#{Process.pid}" )
  sleep second
  puts "#{name} - #{Process.pid} |G/U:#{Process.euid}/#{Process.gid}|PPID:#{Process.ppid}"
  Process.exit
  puts "Never going here"
end

puts "Main process start - #{Process.pid}"

10.times do |t|

    Process.fork do
      test_proc("PROC-#{t}",5+t)
    end

end

#Process.exit
Process.waitall
puts "Main process exit - #{Process.pid}"

运行结果：

多线程示例：

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

require "thread"

threads=[]
6.times do |t|
  threads <<Thread.new do
    puts "Thread-#{t} start: Process: #{Process.pid} "
    sleep 5
    puts "Thread-#{t} Done: Process: #{Process.pid} "
  end
end

threads.each{|t|t.join}

运行结果：

关于多线程与多进程的区别此处就不再赘述了。
Python3中已经具备了非常完善的多线程与多进程的相关库，可以非常容易的实现程序多进程与多线程的功能。

示例代码如下：

多线程示例

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

import os 
import time 
import threading 


def test_proc(name):
    print( "Run child process %s(%s)" % (name,os.getpid()) )
    time.sleep(10)


class MultiThread( threading.Thread ):

    def __init__(self,thread_name):
        threading.Thread.__init__(self)
        self.thread_name = thread_name

    def run(self):
        test_proc("test")


threads = []
for i in range(1,10):
    thread = MultiThread( "Thread-%s" % i )
    thread.start()
    threads.append( thread )

for t in threads:
    t.join()

运行结果：

多进程示例

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

import os 
import time 
import multiprocessing 


def test_proc(name):
    print( "Run child process %s(%s)" % (name,os.getpid()) )
    time.sleep(10)

if __name__=="__main__":
    print("Process start %s" % os.getpid())

    processes = [] 

    for i in range( 0, 10): 
        p=multiprocessing.Process( target=test_proc, args=("Process-%s" % i,) )
        p.start()
        processes.append(p)

    
    for p in processes:
        p.join()

    print( "Main process end.")

运行结果：

VirtualBox虚拟机动态分配的虚拟磁盘用久了以后会变得非常大，相当占用空间。可以采用将磁盘闲置空间重新清零的方法，还原多余的占用空间。

虚拟机中操作

第一步是采用zerofree(Linux)或SDelete(Windows)工具在虚拟机中将磁盘空闲区域清零：

Linux

在Linux虚拟机中，先安装zerofree，以Debian为例，执行 apt-get install zerofree 命令安装。

安装完成后，需要重启虚拟机机器进入Recovery模式，操作过程如下。

开机时进入Advanced options:

在Advanced模式中选择recovery mode:

在Recovery模式下登录后，依次执行以下命令清除/dev/sda1设备的闲置空间：

1
2
3

busybox mount -o ro,remount /dev/sda1
zerofree /dev/sda1
busybox mount -o rw,remount /dev/sda1

其他磁盘设备同理。

Windows

如果是Windows虚拟机，可以在https://docs.microsoft.com/zh-cn/sysinternals/downloads/sdelete 下载微软官方的SDelete工具。

下载后解压并且进入SDelete目录，在CMD中运行SDelete.exe，并提供参数，例如清理C盘，则运行以下命令：

1

SDelete.exe -z C:

主机中操作

等待上述过程执行完成以后，可以进入第二步，在主机中回收虚拟磁盘闲置的空间：

进入Virtualbox的虚拟机目录，这里以一台Debian虚拟机为例，在目录中运行以下命令：

1

"C:\Program Files\Oracle\VirtualBox\VBoxManage.exe" modifyhd Debian.vdi --compact

C:\Program Files\Oracle\VirtualBox\是Virtualbox在Windows 64位系统中的默认安装位置，如果安装位置与此不同，修改即可。

等待执行到100%，即可完成磁盘回收。

磁盘回收的过程中有效数据不会丢失，可以放心操作。

使用aapt工具获取apk的信息，可以使用

1

aapt dump badging xxx.apk

如果没有aapt，使用apt安装：

1

apt-get install aapt

写个脚本批量获取

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

#!/bin/bash 

target=$1
if [ -d $target ] 
then
    for apk in `ls $target/*.apk` 
    do
        app_name=`aapt dump badging $apk | grep 'application: label' | awk -F "'" '{print $2}'`
        echo $apk $app_name
    done 
elif [ ${target#*.} == "apk" ]
then
    app_name=`aapt dump badging $target | grep 'application: label' | awk -F "'" '{print $2}'`
    echo $target $app_name
else 
    echo $target "nOt aN aPk fiLe"
fi 

脚本下载链接：

前言

随着技术的发展，近年很多的网站、移动应用程序、微信小程序等等，采用前后端分离、使用JSON API数据传递这种方式来设计和开发。如此，前端程序可以保持独立、并且相对来说比较完整，后端程序逻辑复杂、性能强劲。前端可以有丰富的对数据的展现方式（图表、动画等等），后端也只需要完善相应的对模型的控制，同时输出一份前端所需要的数据，采用Ajax+JSON方式传递，从而让前后端的开发相对而言都更为轻松，在结构合理、技术完备的情况下，工程层面也能实现较大程度的规模上的突破。

Rails作为一种流行的MVC框架，本身在API的开发上已经有了很成熟的配套设施了。Rails的模板支持.json.jbuilder形式的JSON数据渲染，配合jbuilder从模型对象数组直接创建JSON数据，在开发上有着无与伦比的便利。在此之前，如果使用php开发程序，从数组创建JSON，需要先整理好数组，再json_encode(Array)进行输出，很是麻烦。当然身为PHP程序员的你可能要说，PHP也有很强大的API构建框架，可以很方便的构建出健壮的API，是的，我承认有这些框架的存在，只是限于本人的水平和喜好，在PHP开发方面并没有走的那么深远，也就不熟悉其中的一些高级操作了。如果有兴趣，也可以发邮件就这方面进行一些探讨。

近期由于一个项目的需要，需要从已有的Rails应用中开辟出一个新的独立接口，供客户端程序调用，因此学习了一下Rails API的构建方法，也顺便留下此文，作为记录。关于Rails API的构建，我参考了这篇文章 https://blog.csdn.net/li_001/article/details/65937664

以下就是如何使用Rails构建JSON API

我当前采用的环境是 Ruby 2.4.1 + Rails 5.2.0

配置控制器

首先假设我们的应用已经创建好了，并且建立一个Article模型，包含两个字段，title和content，运行迁移并创建种子数据。

此时进入项目根目录，新建一个控制器：

1

rails g controller api/v1/base --no-assets

这个控制器的代码就会位于app/controllers/api/v1/base_controller.rb，我们需要在其中完善一些权限有关的配置。

由于Rails默认的安全属性，以及我们如果之前自定义了一些控制器中的过滤方法，我们需要在该控制器中跳过它，例如我们首先禁用rails自带的CSRF 保护和CSRF token的输出，以及去除掉返回包中的set-cookies头，由于我的应用还使用了devise作为用户认证的模块，所以还要在此禁用掉authenticate_user方法。
完整的代码如下：

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

class Api::V1::BaseController < ApplicationController
  # disable the CSRF token
  protect_from_forgery with: :null_session

  # disable cookies (no set-cookies header in response)
  before_action :destroy_session

  # disable the CSRF token
  skip_before_action :verify_authenticity_token

  # skip devise user authentication
  skip_before_action :authenticate_user!

  def destroy_session
    request.session_options[:skip] = true
  end
end

创建好base控制器以后，我们需要在这个控制器的基础上派生出一些新的控制器，这里我们新建一个articles控制器

1

rails g controller api/v1/articles --no-assets

此时除了会生成控制器代码以外，还会在app/views/api/v1目录下创建articles目录，作为模板存放的目录。

articles控制器的代码位于app/controllers/api/v1/users_controller.rb，内容如下

先在其中定义一个show方法：

1
2
3
4
5
6

class Api::V1::ArticlesController < Api::V1::BaseController
  def show
    @article = Article.find(params[:id])
  end
end

配置路由

接下来我们对路由config/routes.rb进行配置

1
2
3
4
5

namespace :api do
  namespace :v1 do
    resources :articles
  end
end

配置视图

articles控制器的视图代码位于app/views/api/v1/articles/，我们在其中建立show.json.jbuilder文件，内容如下：

1
2
3

json.article do
  json.(@article, :id, :title, :content)
end

上面这段代码，是jbuilder建立json的语句代码，至于jbuilder的用法，可以参考这篇文章http://ohcoder.com/blog/2015/04/19/jbuilder/

访问接口

启动Rails程序，访问/api/v1/articles/1.json，即可看到接口输出的JSON数据。

接口通信

除了从接口获取JSON数据以外，我们还需要向接口POST JSON数据，并希望接口实现数据的解析和保存。
首先像往常一样，需要在控制器中创建create方法，用于新建数据：

1
2
3

def create
  @host = Host.create(article_params)
end

呵呵，一行代码，是的，就这么简单。
而article_params，则是个私有方法，大概需要这样实现：

1
2
3

def article_params
  params.require(:article).permit(:title, :content)
end

在客户端（或网页中）向该接口发送数据，地址是/api/v1/articles

发送的数据类似下面这样：

1
2
3
4
5
6

{
  "article":{
    "title":"test",
    "content":"a test article from client"
  }
}

直接发送这条数据可能会出错，因为在请求的时候需要带上json格式描述

1
2

Content-Type: application/json
Accept: application/json

完整的POST请求，参考下：

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

POST /api/v1/articles HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json

{
  "article":{
    "title":"test",
    "content":"a test article from client"
  }
}