ubuntu 18.04.1 禁用ipv6

发表于 2019-01-09 | 分类于 ubuntu |

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

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

(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的方法如下：


sudo vi /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="ipv6.disable=1"
GRUB_CMDLINE_LINUX="ipv6.disable=1"
sudo update-grub
sudo reboot

使用flask+tornado搭建一个webssh工具

发表于 2019-01-06 | 分类于 python |

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即可。

<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。


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添加证书和秘钥也非常简单：

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来实现同样的功能。


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方法：

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 强制更新版本的解决方法

发表于 2018-12-28 | 分类于 xshell |

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

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

破解方法

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

树莓派永久设置DNS

发表于 2018-12-25 | 分类于 raspberry |

在使用树莓派上传视频到七牛云的时候，在本地电脑上可以正常上传，但是放到树莓派上就发现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

然后重启树莓派即可。

python 自定义安装脚本并自动安装依赖

发表于 2018-12-25 | 分类于 python |

自定义安装包

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

解决方案

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

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脚本中执行安装依赖：

def run(self):
        install.run(self)
        install.do_egg_install(self)
        ...

使用sqlalchemy自动创建数据库表

发表于 2018-12-21 | 分类于 sqlalchemy |

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

引入flask_script库

需要使用pip进行安装:

1	pip install flask-script

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

创建manage.py文件

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()

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

元类编程

发表于 2018-12-18 | 分类于 python |

什么是元类

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

>>> type(1)
<class 'int'>
>>> type(type(1))
<class 'type'>

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

type和object的关系

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

元类的用法

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

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

禁止实例化的类

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

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方法

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

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

Python中的描述符

发表于 2018-12-17 | 分类于 python |

什么是描述符

python是一种动态的编程语言，因此不能像java那样在编译的时候确定对象的类型，如果我们希望能够像java中的那样规定某个实例属性的类型时该怎么做呢？这就需要用到描述符了。

描述符是实现了特定协议的类, 这个协议就是描述符协议。

描述符协议包括以下三种方法：

get: 用于访问属性
set: 用于设置属性
delete: 用于删除

比如，我们有一个类：

class Demo(object):
    name = ""
d = Demo()
d.name = 7

如果我们希望name固定为str类型，虽然我们可以通过类似get\set方法的来统一读写name属性，但用户仍然可以通过obj.name等方式来设置。我们可以通过添加一个set方法来控制该属性的类型。

class BeString(object):
    def __init__(self,name):
        self.name = name
    def __set__(self,instance,value):
        if isinstance(value,str):
            instance.__dict__[self.name] = value
        else:
            raise Exception("Must be str.")
class Demo(object):
    name = BeString("name")
d = Demo()
d.name = 7
----------
Traceback (most recent call last):
  File "demo_descriptor.py", line 25, in <module>
    d.name = 7
  File "demo_descriptor.py", line 18, in __set__
    raise Exception("Must be str.")
Exception: Must be str.

覆盖型描述符合非覆盖型描述符

如上述示例，包含set特殊方法的类称为覆盖型描述符，只包含get特殊方法的类称为非覆盖型描述符。

使用覆盖型描述符会覆盖实例属性的赋值操作：

class BeString(object):
    def __init__(self,name):
        self.attr_name = name
    def __set__(self,instance,value):
        if isinstance(value,str):
            instance.__dict__[self.attr_name] = value
        else:
            raise Exception("Must be str.")
class Demo(object):
    name = BeString("xname")
d = Demo()
d.name = "张三"
print(vars(d))
------------
{'xname': '张三'}

为了区别显示，我这里把描述符的名称设置为了xname，从d的dict来看，set方法覆盖了实例属性的赋值操作d.name

恢复正常的显示：

class BeString(object):
    def __init__(self,name):
        self.attr_name = name
    def __set__(self,instance,value):
        if isinstance(value,str):
            instance.__dict__[self.attr_name] = value
        else:
            raise Exception("Must be str.")
    def __get__(self,instance,type):
        return instance.__dict__[self.attr_name]
class Demo(object):
    name = BeString("xname")
d = Demo()
d.name = "张三"
print(vars(d))
print(d.name)
---------
{'xname': '张三'}
张三

如果删掉set方法就成了非覆盖型描述符，如下例：

class BeString(object):
    def __init__(self,name):
        self.attr_name = name
    def __get__(self,instance,type):
        return "随便起个名"
class Demo(object):
    name = BeString("xname")
    family_name = BeString("fname")
d = Demo()
d.name = "张三"
print(vars(d))
print(d.name)
print(d.family_name)
---------
{'name': '张三'}
张三
随便起个名

因为实例属性存在，__get__方法并没有被调用。而familyname不存在示例属性，则调用了描述符的\_get__方法显示了”随便起个名”的文字。

在类中覆盖描述符

在类中给类属性赋值都会覆盖掉描述符，这是一种猴子补丁技术，不管是不是覆盖型描述符。
如下面的例子：

class BeString(object):
    def __init__(self,name):
        self.attr_name = name
    def __set__(self,instance,value):
        if isinstance(value,str):
            instance.__dict__[self.attr_name] = value
        else:
            raise Exception("Must be str.")
    def __get__(self,instance,type):
        return "随便起个名"
class Demo(object):
    name = BeString("xname")
    family_name = BeString("fname")
d = Demo()
Demo.name = 7
Demo.family_name = "TEST"
print(vars(d))
print(d.name)
print(d.family_name)
--------
{}
7
TEST

可以看到，不论是__set__还是__get__都没有生效，哪怕在后续的操作中继续使用实例方法也不会有效。

d = Demo()
Demo.name = 7
Demo.family_name = "TEST"
d.name = 9
d.family_name = 11
------
{'name': 9, 'family_name': 11}
9
11

另外，

d = Demo()
Demo.name = 7
print(vars(d))
print(d.name)
print(Demo.family_name)
-----
{}
7
随便起个名

从这里能看出来，在读取类的属性上，是可以调用类上面的描述符处理，而写却不行。

class BeString(object):
    def __init__(self,name):
        self.attr_name = name
    def __set__(self,instance,value):
        if isinstance(value,str):
            instance.__dict__[self.attr_name] = value
        else:
            raise Exception("Must be str.")
    def __get__(self,instance,type):
        return "随便起个名"
class Demo(object):
    name = BeString("name")
d = Demo()
d.name = "小王"
print(vars(d))
print(d.name)
-----
{'name': '小王'}
随便起个名

属性查找的顺序

当使用实例对象访问属性的时候，查找会以下面的顺序进行：

类属性——>覆盖型描述符——>实例属性——>非覆盖型描述符——> __getattr__

getattr和getattribute

getattr会在getattribute找不到属性的时候被调用,getattribute是属性查找的入口，其内部实现了我们上述的查找顺序。

class Demo(object):
    def __getattribute__(self,item):
        print("开始查找")
        # return super(Demo,self).__getattribute__(item)
        raise AttributeError("")
    def __getattr__(self,item):
        print("没有找到，返回默认值")
        return "000"
    name = BeString("name")
d = Demo()
d.mono

如果我们自己实现getattribute，则需要手动抛出AttributeError才能调用到getattr.

描述符在很多著名的框架中都有引用，像Django中的ORM，SQLalchemy等，都是描述符应用的范例。

极光推送的坑

发表于 2018-12-12 | 分类于 jpush |

项目中使用了极光推送，本地调试可以，但是一旦放到服务器上就会报下面的错误：

1	Connection to api.jpush.cn error.

经测试，api.jpush.cn在服务器上是可以正常访问的。
后来在极光的论坛上看到了一条，说必须开放主机的443端口，开放了443之后果然就可以正常使用了。

但是还是比较纳闷，我去掉极光的接口，为什么极光一定要让我开放443端口呢？后台代码跑在docker中，docker的443端口并未映射到host上。论坛只见说要必须开放，至于为什么，怕是只有极光自己的人知道了。

VMware 桥接模式下获取不到IP地址

发表于 2018-12-11 | 分类于 vmware |

VBOX在无线模式下老是获取不到ip，无奈换回了VMware结果这货居然在桥接模式下也无法获取IP。

解决方案

在编辑-虚拟网络编辑器菜单中，更改桥接模式桥接的网卡。

禁用ipv6

原理

xterm.js的使用

tornado 中使用websocket

处理secure websocket

paramiko

跳坑指南

Nignx部署400错误

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

Websocket报403错误

运行界面：

破解方法

自定义安装包

解决方案

引入flask_script库

创建manage.py文件

自动添加数据库表

什么是元类

type和object的关系

元类的用法

禁止实例化的类

单例模式

什么是描述符

覆盖型描述符合非覆盖型描述符

在类中覆盖描述符

属性查找的顺序

__getattr和__getattribute

解决方案

getattr和getattribute