发表于 | 分类于 |

以前讲过如何做一个自己的python包，现在说一下如何将自己制作的包上传到pypi, 然后就可以像我们使用别的轮子一样使用自己的轮子了。

注册pypi

首先需要去 pypi.org 注册一个自己的账号和密码

生成自己的python包

使用

setup.py sdist```命令即可创建
1
2
3
4
5
6
7
# 上传
首先需要安装twine：
```sh
sudo pip install twine

然后使用命令twine上传就可以了

1
python3 setup.py sdist upload dist/youregg.tar.gz

发表于 | 分类于 |

在上传自己的包到pypi的时候，碰到了一个错误：

1
pkg_resources.ContextualVersionConflict: (idna 2.8 (/home/kevin/.local/lib/python3.6/site-packages), Requirement.parse('idna<2.7,>=2.5') {requests}

这个错误的原因是requests库使用的idna库的版本过低。解决方法是降低idna版本或者升级requests版本即可。

发表于 | 分类于 |

有个需求需要知道自己的公网IP地址，网上的方法大概有如下几种：

1
curl ipinfo.io

通过访问第三方网站获取自己的IP，优点是简单，缺点是不够稳定，运气不好会经常访问超时。

还有一种是通过DNS

1
dig @resolver1.opendns.com ANY myip.opendns.com +short

这种方法的问题是 获取的IP未必是自己的真实的IP，不够可靠。

后来想了想，与其用别人提供的服务，不如自己写一个，原理也非常简单，就是写一个方法，通过Nginx获取到来访者的公网IP，然后将其回显到页面上。

发表于 | 分类于 |

虚拟机重启以后，突然发现做好的docker端口映射不能使用了，docker本身还在运行，但是就是访问不了服务。

通过 netstat -lntp命令查看端口使用情况:

1
2
3
4
5
6
7
8
9
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      -                   
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -                   
tcp6       0      0 :::8069                 :::*                    LISTEN      -                   
tcp6       0      0 :::8071                 :::*                    LISTEN      -                   
tcp6       0      0 :::22                   :::*                    LISTEN      -

原来端口居然变成了tcp6

禁用ipv6

ubuntu 18.04.1 禁用ipv6的方法如下：

1
2
3
4
5
6
7
8
sudo vi /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="ipv6.disable=1"
GRUB_CMDLINE_LINUX="ipv6.disable=1"
sudo update-grub
sudo reboot

发表于 | 分类于 |

xshell确实好用，但是不便于辗转流连于多个电脑之间，虽然用onedrive解决了多台电脑之间的秘钥文件的存储问题，但是令人讨厌的秘钥密码却总是如幽灵般的闪现，偶尔记不住某个服务器的密码就要翻箱倒柜地寻找密码薄。因此，一直有一个想法，就是搞一套webssh，像登录网站那样登录ssh，这样不论在哪台电脑上工作，只要有一个浏览器，就可以随时登录服务器，岂不快哉。

原理

首先要了解我们使用webssh的工作原理，传统单工的http协议并不能满足我们的要求，我们要求实时双工通信，因此前端的协议就是websocket，前端处理终端字符有一个非常著名的库xterm.js, 最近非常流行的vscode的terminal就是使用xterm.js编写的。后端websocket服务采用tornado, ssh通信及认证等工作交给python的paramiko库。

原理图大概如下这个样子：

xterm.js的使用

了解了原理，接下来我们来实现它。首先我们先看一下xterm.js这个工具的使用。
xterm.js是一个非常强大的库，可以帮我们简化很多的工作和麻烦，有了xterm.js，我们不需要考虑terminal下的各种字符的问题。

xterm.js的官网。

我们使用的代码比较简单，只需要引入xterm.js,然后创建一个websocket即可。

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
<head>
  <link rel="stylesheet" href="{{ url_for('static', filename='dist/xterm.css') }}" />
  <link rel="stylesheet" href="{{ url_for('static', filename='dist/addons/fullscreen/fullscreen.css') }}" />
  <!-- <link rel="stylesheet" href="/dist/style.css" /> -->
  <script src="{{ url_for('static', filename='dist/xterm.js') }}"></script>
  <script src="{{ url_for('static', filename='dist/addons/fullscreen/fullscreen.js') }}"></script>
  <script src="{{ url_for('static', filename='dist/addons/fit/fit.js') }}"></script>
</head>
<body>
  <div class="container">
    <div id="terminal-container"></div>
  </div>
  <script>
    // terminado.apply(Terminal);
    console.log("加载addons");
    Terminal.applyAddon(fit);
    // 获取网页高度和宽度
    var cols = parseInt(document.documentElement.clientWidth/9.5,10)
    var rows = parseInt(document.documentElement.clientHeight/18,10)
    var term = new Terminal({
      cols: cols,
      rows: rows
    }),
      protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://',
      socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + "/websocket/{{server_id}}";
    sock = new WebSocket(socketURL);
    sock.addEventListener('open', function () {
      // term(sock);
      //发送当前窗口大小
      sock.send("size:" + cols + "," + rows)
      term.on('data', function (data) {
        sock.send(data);
      });
    });
    sock.addEventListener("message", function (msg) {
      term.write(msg.data)
    });
    term.open(document.getElementById('terminal-container'));
    // term.write("Hello");
    term.fit();
    // term.toggleFullScreen(true);
  </script>
</body>

xterm.js自带了两个插件，一个fit,另一个fullscreen,使用fullscreen的时候需要注意，不要忘了引用css文件。详细使用说明请参考官网说明文档。

tornado 中使用websocket

tornado是一个强大的web应用框架，其最受关注的功能是对异步的支持，它使得处理非阻塞请求更容易，最终导致更高效的处理以及更好的可扩展性，同时也支持websocket. 所以，我们这里选用的websocket实现就是tornado。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from tornado.web import FallbackHandler, Application, StaticFileHandler
from tornado.wsgi import WSGIContainer
from tornado.ioloop import IOLoop
from app.ws.server import SshHandler
rom tornado.httpserver import HTTPServer
import ssl
import os
app = WSGIContainer(app)
handlers = [
    (r"/websocket/(.*)", SshHandler,{}),
    (r"/(.*)", FallbackHandler, dict(fallback=app))
]
application = Application(handlers,debug=True)

这里不仅使用了websocket，还是用flask部分代码，是因为我的项目中http请求是用flask来实现的。

处理secure websocket

webssh这么敏感的业务肯定是要跑在secure websocket上的，tornado添加证书和秘钥也非常简单：

1
2
3
4
5
6
7
httpserver = HTTPServer(application,ssl_options={
            "certfile": os.path.join(config.read("secure_path"), "1_home.mixoo.cn_bundle.crt"),
            "keyfile":  os.path.join(config.read("secure_path"), "2_home.mixoo.cn.key"),
        })
httpserver.listen(int(config.read("PORT")))
    IOLoop.current().start()

这样就构建好了服务端的websocket。

paramiko

xterm.js官方使用的是termindo,一个由tornado编写而来的演示框架，但是它只支持本机的ssh，并不能满足我们希望连接其他主机的跳板需求。
这里是用的解决方案是python的paramiko库，paramiko提供很多接口供我们使用，能让我们轻松地完成ssh连接操作。

通常我们远程登录主机使用的验证方式有两种，一种是用户名和密码认证，另一种是私钥公钥认证，有时候私钥还会有密码。这些在xshell等工具中都有配置，我们现在就用paramiko来实现同样的功能。

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
class SSH(object):
    def __init__(self, host, port, user, password=None, keyfile=None, passphrase=None):
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.keyfile = keyfile
        self._ssh = paramiko.SSHClient()
        self._ssh.load_system_host_keys()
        self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        k = keyfile and paramiko.RSAKey.from_private_key_file(
            keyfile, password=passphrase) or None
        self._ssh.connect(hostname=host, port=port, username=user,
                          password=password, pkey=k)
        self._chanel = self._ssh.invoke_shell(
            term='xterm')
    def resize(self, cols, rows):
        self._chanel.resize_pty(width=cols, height=rows)
    def send(self, msg):
        self._chanel.send(msg)
    def read(self):
        return self._chanel.recv(10000)

核心代码不多，主要的方法就是connect，在其中要将用户名和密码、端口等信息都配置好。如果有私钥，私钥又有密码，就使用from_private_key_file方法把私钥文件名和密码传入。invoke_shell方法返回一个channel，拿到这个channal就可以像xshell一样打开一个terminal一样来操作了。

跳坑指南

Nignx部署400错误

本地测试完，部署服务器的时候碰到nginx返回400错误。原因是忘了在nginx配置中将协议升级为websocket:

1
2
3
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;

RuntimeError: There is no current event loop in thread ‘Thread-1’.

也是在部署服务器的时候出现的，原因是本地tornado版本是4.5.3，而服务器版本变成了5.1. 在5.1版本中使用多线程，就会出现上述错误。解决方案就是使用asyncio的set_event_loop方法：

1
2
3
4
5
6
import asyncio
def _reading(self):
        asyncio.set_event_loop(asyncio.new_event_loop())
        while True:
            data = self.ssh.read()
            self.write_message(data)

Websocket报403错误

也是因为服务器版本5.1的问题，解决方案，在websocket的handler中添加一个check_origin方法：

1
2
def check_origin(self, origin):
    return True

运行界面：

点击终端进入webssh界面：

发表于 | 分类于 |

要继续使用此程序，您必须应用最新的更新或使用新版本

用的好好的xshell 5，突然间就不让用了，提示什么必须要在更新再使用。鉴于之前用过xshell6，对于免费版只能同时开4个tab的限制实在不能忍受，才退回了xshell 5. 看来官方这是要把人逼上梁山啊。

破解方法

下载 ns.dll 放到xshell的安装目录，覆盖即可。

发表于 | 分类于 |

在使用树莓派上传视频到七牛云的时候，在本地电脑上可以正常上传，但是放到树莓派上就发现DNS解析错误

使用cat /etc/resolv.conf查看树莓派的DNS设置：

1
2
3
nameserver 114.114.114.114
nameserver 220.x.x.x

看起来没有什么问题，可就是ping不同七牛的域名uc.qbox.me

后来发现uc.qbox.me的服务器在北美，可能国内某些dns解析不成功。
于是给树莓派换DNS服务器就成了必须要的一步：

编辑 /etc/resolvconf.conf：

加入一条：

1
name_servers=8.8.8.8

然后重启树莓派即可。

发表于 | 分类于 |

自定义安装包

在之前的文章中，我们介绍过如何自定义一个安装包，并制作自己的启动脚本，但是之前的步骤中存在一个问题，就是如果我们自定义了Install脚本，将无法自动安装依赖。

解决方案

自动安装依赖的脚本实际是在Install类中调用了easy_install,我们可以在我们的脚本中调用该方法实现手动安装依赖的效果。

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
setup(name='MoYao-Raspberry-Controller',
      version=moyao.__version__,
      description='Python Distribution Utilities',
      author='Kevin Kong',
      author_email='kfxw2007@163.com',
      license='http://www.apache.org/licenses/LICENSE-2.0.html',
      url='',
      data_files=data_files,
      packages=find_packages(),
      package_dir={'%s' % 'moyao': 'moyao'},
      include_package_data=True,
      python_requires='>=3.5',
      install_requires=[
          "pywifi",
          "autils",
          "picamera",
          "configparser",
          "pyserial",
          "pexpect",
          "requests",
          "pywifi",
          "paho-mqtt",
          "qiniu"
      ],
      cmdclass={
          'install': InstallCommand,
      },
    )

在Install脚本中执行安装依赖：

1
2
3
4
def run(self):
        install.run(self)
        install.do_egg_install(self)
        ...

发表于 | 分类于 |

需求如标题，废话不多说，直接上代码，本篇使用的flask+postgresql组合。

引入flask_script库

需要使用pip进行安装:

1
pip install flask-script

使用时需要注意，原有的flask.ext.script已经废弃，请使用flask_script代替。

创建manage.py文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from flask_script import Manager, Server
from app import app, db
from app.model import user, notify
manager = Manager(app)
manager.add_command("server", Server())
@manager.shell
def make_shell_context():
    return dict(app=app, db=db, User=user.User, CfgNotify=notify.CfgNotify)
if __name__ == "__main__":
    manager.run()

以后每创建一个model都要加到make_shell_context方法的dict中。

自动添加数据库表

进入shell:

1
2
python3 manage.py shell
>> db.create_all()

这样就会根据数据库配置，自动创建表结构

发表于 | 分类于 |

什么是元类

元类的定义非常简单，就是创建类的类。我们都知道，我们自己定义的类都是object的子类，但也许你不知道，所有的类的最终类型都是type.

1
2
3
4
>>> type(1)
<class 'int'>
>>> type(type(1))
<class 'type'>

元类是制造类的工厂，不过不是函数，而是类。默认情况下，python中的类是type类的实例，也就是说，type是大多数内置类和用户类的元类。

type和object的关系

为了避免无限回溯，type是其自身的实例。object是type的实例，而type是object的子类。这种关系很神奇，无法使用python代码表述，因为定义其中一个之前另一个也必须存在。

元类的用法

“元类就是深度的魔法，99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类，那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么，而且根本不需要解释为什么要用元类。” —— Python界的领袖 Tim Peters

这里举两个简单的元类的使用例子:

禁止实例化的类

如果希望有一个类，只可以通过类方法或静态方法调用，而不允许实例化该类，这就需要通过元类来控制类的生成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class NoInstance(type):
    def __call__(cls, *args, **kwargs):
        raise TypeError("不能创建该类的实例")
class Jim(metaclass=NoInstance):
    @staticmethod
    def run():
        print('Jim Run!')
---------
>>> from meta_demo import Jim
>>> j = Jim()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/mnt/hgfs/Codes/scripts/python/metacls/meta_demo.py", line 64, in __call__
    raise TypeError("不能创建该类的实例")
TypeError: 不能创建该类的实例

metaclass是python3的使用方式，python2中需要使用metaclass来指定元类

单例模式

我们可以使用元类来实现单例模式，而不是用类的new方法

1
2
3
4
5
6
7
8
9
10
11
12
13
class Singleton(type):
    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        super().__init__(*args, **kwargs)
    def __call__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance
class Dog(metaclass=Singleton):
    pass

大多数时候我们并需要使用元类，也不便于维护，除非是要自己创建一个框架。