东东东 陈煜东的博客

年份存档: 2018

Python mock http requests 单元测试用例测试

在写 Python Mock 的 requests测试用例,需要mock对方服务的http返回包行为,方便进行调试。而如果对方还没准备好,或者有副作用,又不敢直接请求。因此我们需要一个 Mock 的功能。

以前使用 Python 自带的 Mock 类库来进行,感觉写起来总感觉有点不顺畅。

在网上找到了一个类库 requests_mock ,用起来很方便,这里给大家分享一下。

requests 类库有一个可插件化的传输层适配器,并且允许你根据不同的url或者协议注册自己的handler。requests-mock的核心就是一个简单的被提前加载的传输层适配器。

安装 requests_mock

pip install requests_mock

使用 Mocker

通过 Context Manager方法使用

>>> import requests
>>> import requests_mock

>>> with requests_mock.Mocker() as m:
...     m.get('http://test.com', text='resp')
...     requests.get('http://test.com').text
...
'resp'

通过装饰器使用

>>> @requests_mock.Mocker()
... def test_function(m):
...     m.get('http://test.com', text='resp')
...     return requests.get('http://test.com').text
...
>>> test_function()
'resp'

这种方法需要在参数的最后一个位置进行声明,会传递进来这个对象。

如果有冲突,可以提前指定好。例如

>>> @requests_mock.Mocker(kw='mock')
... def test_kw_function(**kwargs):
...     kwargs['mock'].get('http://test.com', text='resp')
...     return requests.get('http://test.com').text
...
>>> test_kw_function()
'resp'

类装饰器

>>> requests_mock.Mocker.TEST_PREFIX = 'foo'
>>>
>>> @requests_mock.Mocker()
... class Thing(object):
...     def foo_one(self, m):
...        m.register_uri('GET', 'http://test.com', text='resp')
...        return requests.get('http://test.com').text
...     def foo_two(self, m):
...         m.register_uri('GET', 'http://test.com', text='resp')
...         return requests.get('http://test.com').text
...
>>>
>>> Thing().foo_one()
'resp'
>>> Thing().foo_two()
'resp'

类似 unitest 一样寻找测试函数开头前缀, requests_mock 也是类似的寻找测试函数,不过不想test前缀开头,可以用requests_mock.Mocker.TEST_PREFIX 来指定。

请求真实的HTTP服务

通过real_http关键字,可以请求真实的 HTTP 服务。

>>> with requests_mock.Mocker(real_http=True) as m:
...     m.register_uri('GET', 'http://test.com', text='resp')
...     print(requests.get('http://test.com').text)
...     print(requests.get('http://www.google.com').status_code)  
...
'resp'
200

或者

>>> with requests_mock.Mocker() as m:
...     m.register_uri('GET', 'http://test.com', text='resp')
...     m.register_uri('GET', 'http://www.google.com', real_http=True)
...     print(requests.get('http://test.com').text)
...     print(requests.get('http://www.google.com').status_code)  
...
'resp'
200

Mock url 的方法

其实上面已经简单提到了,主要是用

adapter.register_uri('GET', url, ...)

匹配具体的url地址

只要协议和url地址都匹配上,才有效。

.. >>> adapter.register_uri('GET', 'mock://test.com/path', text='resp')
.. >>> session.get('mock://test.com/path').text
.. 'resp'

url中的path 路径匹配

比如不管协议,主要域名匹配上就行。

.. >>> adapter.register_uri('GET', '//test.com/', text='resp')
.. >>> session.get('mock://test.com/').text
.. 'resp'

或者主要url中的path匹配就行

.. >>> adapter.register_uri('GET', '/path', text='resp')
.. >>> session.get('mock://test.com/path').text
.. 'resp'
.. >>> session.get('mock://another.com/path').text
.. 'resp'

匹配url中的 query 参数部分

>>> adapter.register_uri('GET', '/7?a=1', text='resp')
>>> session.get('mock://test.com/7?a=1&b=2').text
'resp'

匹配任意 http method,比如get、 post

>>> adapter.register_uri(requests_mock.ANY, 'mock://test.com/8', text='resp')
>>> session.get('mock://test.com/8').text
'resp'
>>> session.post('mock://test.com/8').text
'resp'

下面是无脑什么url地址,直接返回指定的response

>>> adapter.register_uri(requests_mock.ANY, requests_mock.ANY, text='resp')
>>> session.get('mock://whatever/you/like').text
'resp'
>>> session.post('mock://whatever/you/like').text
'resp'

更多的匹配url的方法,参考 https://requests-mock.readthedocs.io/en/latest/matching.html

动态返回 response

通过上面的动态匹配 url 地址,接下来可能多次请求一个url地址需要返回不同的数据。

主要还是利用上面的 requests_mock.Adapter.register_uri() 这个函数来支持。

注册 Reponses

register_uri 用于模拟http的请求。 主要有参数控制 response的一些 header 信息。

status_code:    The HTTP status response to return. Defaults to 200.
reason:         The reason text that accompanies the Status (e.g. ‘OK’ in ‘200 OK’)
headers:    A dictionary of headers to be included in the response.
cookies:    A CookieJar containing all the cookies to add to the response.

还有控制body的的参数

json:       A python object that will be converted to a JSON string.
text:       A unicode string. This is typically what you will want to use for regular textual content.
content:    A byte string. This should be used for including binary data in responses.
body:       A file like object that contains a .read() function.
raw:        A prepopulated urllib3.response.HTTPResponse to be returned.
exc:        An exception that will be raised instead of returning a response.

这些参数都是 requests.Response 对象的成员变量。

使用示例

>>> adapter.register_uri('GET', 'mock://test.com/1', json={'a': 'b'}, status_code=200)
>>> resp = session.get('mock://test.com/1')
>>> resp.json()
{'a': 'b'}

>>> adapter.register_uri('GET', 'mock://test.com/2', text='Not Found', status_code=404)
>>> resp = session.get('mock://test.com/2')
>>> resp.text
'Not Found'
>>> resp.status_code
404

动态响应

requests_mock 提供了一个回调函数,用于进行动态判断。

def callback(request, context):

request请求的对象和,context是返回的response对象

request:    The requests.Request object that was provided.
context:    An object containing the collected known data about this response.

使用示例

>>> def text_callback(request, context):
...     context.status_code = 200
...     context.headers['Test1'] = 'value1'
...     return 'response'
...
>>> adapter.register_uri('GET',
...                      'mock://test.com/3',
...                      text=text_callback,
...                      headers={'Test2': 'value2'},
...                      status_code=400)
>>> resp = session.get('mock://test.com/3')
>>> resp.status_code, resp.headers, resp.text
(200, {'Test1': 'value1', 'Test2': 'value2'}, 'response')

按指定list结果返回

提前写好需要返回的 response 列表。依次返回。

>>> adapter.register_uri('GET', 'mock://test.com/4', [{'text': 'resp1', 'status_code': 300},
...                                                   {'text': 'resp2', 'status_code': 200}])
>>> resp = session.get('mock://test.com/4')
>>> (resp.status_code, resp.text)
(300, 'resp1')
>>> resp = session.get('mock://test.com/4')
>>> (resp.status_code, resp.text)
(200, 'resp2')
>>> resp = session.get('mock://test.com/4')
>>> (resp.status_code, resp.text)
(200, 'resp2')

demo 1 : 需要请求获取任务id,然后查询运行中,然后成功的场景

import json
import time
from unittest import TestCase
from threading import Thread

import requests_mock

def task_result_success(m):
    """想要成功的时候的返回包"""
    time.sleep(0.05)
    resp = {"data": {},
            "code": "OK"}

    m.register_uri(requests_mock.ANY, requests_mock.ANY, text=json.dumps(resp))


@requests_mock.Mocker()
def test(m):
    resp = {"code": "OK", 
            "data": {"task_id": "xxxxx"}
                }
    # 注册结果,直接返回需要的任务id
    m.register_uri(requests_mock.ANY, requests_mock.ANY, text=json.dumps(resp))

    Thread(target=task_result_success, args=(m,)).start()   # 过一会后,mock对象的返回包会被替代。

    your.dosomething()  # 自己的业务逻辑,这里会请求获得一个任务ID,然后查询直接返回成功。

这里通过 pytest 运行了 test() 函数,先对http请求返回一个任务id的返回包。然后开启一个线程,过0.05s后,返回一个成功的请求包。

因为执行了 your.dosomething() 会阻塞主线程,所以通过一个子线程来修改 Mocker 对象的返回。想了好久想到的这么一个方法。

demo 2: 也是轮训taskid,然后返回的running,然后success

# 定义返回的顺序
response_list = [
    {'json': get_task_id_resp(), },
    {'json': get_task_query_running_resp(), },
    {'json': get_task_query_success_resp(), }
]

# 注册
m.register_uri(requests_mock.ANY, requests_mock.ANY, response_list)

# 执行调用代码开始测试,观察log
your.dosomething()

声明:未经允许禁止转载 东东东 陈煜东的博客 文章,谢谢。如经授权,转载请注明: 转载自东东东 陈煜东的博客

本文链接地址: Python mock http requests 单元测试用例测试 – https://www.chenyudong.com/archives/python-mock-http-request.html

分类: Python

进程不见了,Linux 的OOM Killer

背景

服务器的某个模块的进程莫名其妙的不见了,查看MQ的连接情况,该模块的连接数直接为0,但是其他模块的进程还存在。很是纳闷该模块的进程为什么进程突然不见了。

oom-killer-mq-consumer-connnection

查看进程的log文件,没有发现有stop信号收到。平时停止会收到kill信号。

[12:29:37.290]:[executor.py:_fun: 53]: Info: proc[28269] recv signal[15]
[12:29:37.314]:[mq.py:_consuming:181]: service received STOP signal, stop consume

一下子没有反应过来会被kill 9。想到平时大家都会去/var/log/message查看,打开文件一看:

Dec  2 10:10:00 localhost kernel: [53533657.927030] python invoked oom-killer: gfp_mask=0x200da, order=0, oom_adj=0
Dec  2 10:10:00 localhost kernel: [53533657.927033] Pid: 19679, comm: python Not tainted  #1
Dec  2 10:10:00 localhost kernel: [53533657.927035] Call Trace:
Dec  2 10:10:00 localhost kernel: [53533657.927041]  [<ffffffff81089f9a>] oom_kill_process.clone.0+0xaa/0x270
Dec  2 10:10:00 localhost kernel: [53533657.927043]  [<ffffffff8108a278>] __out_of_memory+0x118/0x180
Dec  2 10:10:00 localhost kernel: [53533657.927045]  [<ffffffff8108a3ba>] out_of_memory+0xda/0x160
Dec  2 10:10:00 localhost kernel: [53533657.927048]  [<ffffffff8108e9cd>] __alloc_pages_nodemask+0x61d/0x630
Dec  2 10:10:00 localhost kernel: [53533657.927052]  [<ffffffff810b8ce3>] alloc_page_vma+0x93/0x150
Dec  2 10:10:00 localhost kernel: [53533657.927054]  [<ffffffff810af10e>] read_swap_cache_async+0xde/0x130
Dec  2 10:10:00 localhost kernel: [53533657.927061]  [<ffffffff810af868>] ? valid_swaphandles+0x68/0x160
Dec  2 10:10:00 localhost kernel: [53533657.927063]  [<ffffffff810af1df>] swapin_readahead+0x7f/0xb0
Dec  2 10:10:00 localhost kernel: [53533657.927067]  [<ffffffff810a09e2>] handle_mm_fault+0x392/0x9d0
Dec  2 10:10:00 localhost kernel: [53533657.927071]  [<ffffffff8102eaa0>] do_page_fault+0x110/0x2e0
Dec  2 10:10:00 localhost kernel: [53533657.927076]  [<ffffffff817de855>] page_fault+0x25/0x30
...
Dec  2 10:10:00 localhost kernel: [53533657.964521] Out of memory: kill process 21270 (python) score 1508 or a child
Dec  2 10:10:00 localhost kernel: [53533657.964523] Killed process 21360 (python)

原来是OOM,给杀死进程了。以为OOM会随便杀进程,之前也出现过一次,也是同一模块的进程都被杀了。于是上网搜索了一次OOM挑选进程的算法。

Linux 如何选择要kill掉的进程

从网上的找了一个比较全面的如下:

OOM Killer在内存耗尽时,会查看所有进程,并分别为每个进程计算分数。将信号发送给分数最高的进程。 
计算分数的方法 
在OOM Killer计算分数时要考虑很多方面。首先要针对每个进程确认下列1~9个事项再计算分数。 
1. 首先,计算分数时是以进程的虚拟内存大小为基准的,虚拟内存大小可以使用ps命令的VSZ或/proc/<PID>/status的 VmSize来确认。对于正在消耗虚拟内存的进程,其最初的得分较高,单位是将1KB作为1个得分,消耗1GB内存的进程,得分约为1024*1024。 
2. 如果进程正在执行swapoff系统调用,则得分设置为最大值(unsigned long的最大值)。这是因为禁用swap的行为与消除内存不足是相反的,会立刻将其作为OOM Killer的对象进程。 
3. 如果是母进程,则将所有子进程内存大小的一半作为分数。 
4. 根据进程的CPU使用时间和进程启动时间调整得分,这是因为在这里认为越是长时间运行或从事越多工作的进程越重要,需保持得分较低。 
5. 对于通过nice命令等将优先级设置得较低的进程,要将得分翻倍。nice-n中设置为1~19的命令的得分翻倍。 
6. 特权进程普遍较为重要,因此将其得分设置为1/4。 
7. 通过capset(3)等设置了功能(capability)CAP_SYS_RAWIO注3的进程,其得分为1/4,将直接对硬件进行操作的进程判断为重要进程。 
8. 关于Cgroup,如果进程只允许与促使OOM Killer运行的进程所允许的内存节点完全不同的内存节点,则其得分为1/8。 
9. 最后通过proc文件系统oom_adj的值调整得分。 

依据以上规则,为所有进程打分,向得分最高的进程发送信号SIGKILL(到Linux 2.6.10为止,在设置了功能CAP_SYS_RAWIO的情况下,发送SIGTERM,在没有设置的情况下,发送SIGKILL)。 
各进程的得分可以使用/proc/<PID>/oom_score来确认。 


来自: https://blog.csdn.net/JeffreyNicole/article/details/47263235 

上面的算法看着有点复杂,另外 Linux 的系统选择的策略不断在演进,还是得看正在用的版本的算法。

大概的算法的意思是:通过设置一些值来影响OOM killer做出决策。Linux下每个进程都有个OOM权重,在 /proc/<pid>/oom_adj里面,取值是-17+15,取值越高,越容易被干掉。

最终OOM killer是通过 /proc/<pid>/oom_score 这个值来决定哪个进程被干掉的。这个值是系统综合进程的内存消耗量、CPU时间(utime + stime)、存活时间(uptime – start time)和oom_adj计算出的,消耗内存越多分越高,存活时间越长分越低。

总之,总的策略是:损失最少的工作,释放最大的内存同时不伤及无辜的用了很大内存的进程,并且杀掉的进程数尽量少。 另外,Linux在计算进程的内存消耗的时候,会将子进程所耗内存的一半同时算到父进程中。

这也说明了,为什么有内存用的很多的模块,却没有被kill了,而是kill了一个cpu使用时间少的一个模块。因为内存大的模块,CPU的运行时间长,所以分数比较低。

top - 17:23:31 up 619 days, 21:41, ? users,  load average: 1.59, 1.88, 1.62
Tasks: 651 total,   1 running, 650 sleeping,   0 stopped,   0 zombie
Cpu(s): 15.7%us,  1.6%sy,  0.0%ni, 74.5%id,  8.1%wa,  0.0%hi,  0.1%si,  0.0%st
Mem:  24738212k total, 24577344k used,   160868k free,     2068k buffers
Swap:  2097144k total,  2097144k used,        0k free,    79416k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND
17880 root      20   0 1075m 895m 1632 S  0.0  3.7 123:55.47 python
17897 root      20   0 1076m 894m 1632 S  0.0  3.7 122:55.16 python
17840 root      20   0 1064m 893m 1632 S  0.0  3.7 125:09.59 python

/proc/$pid/oom_score_adj

The value of /proc/<pid>/oom_score_adj is added to the badness score before it
is used to determine which task to kill.  Acceptable values range from -1000
(OOM_SCORE_ADJ_MIN) to +1000 (OOM_SCORE_ADJ_MAX).  This allows userspace to
polarize the preference for oom killing either by always preferring a certain
task or completely disabling it.  The lowest possible value, -1000, is
equivalent to disabling oom killing entirely for that task since it will always
report a badness score of 0.

在计算最终的 badness score 时,会在计算结果是中加上 oom_score_adj ,这样用户就可以通过该在值来保护某个进程不被杀死或者每次都杀某个进程。其取值范围为-1000到1000 。

如果将该值设置为-1000,则进程永远不会被杀死,因为此时 badness score 永远返回0。

/proc/$pid/oom_adj

The value of /proc/<pid>/oom_score_adj is added to the badness score before it

For backwards compatibility with previous kernels, /proc/<pid>/oom_adj may also
be used to tune the badness score.  Its acceptable values range from -16
(OOM_ADJUST_MIN) to +15 (OOM_ADJUST_MAX) and a special value of -17
(OOM_DISABLE) to disable oom killing entirely for that task.  Its value is
scaled linearly with /proc/<pid>/oom_score_adj.

该设置参数的存在是为了和旧版本的内核兼容。其设置范围为-17到15。从Linux 2.6.36开始都安装了/proc/<pid>/oom_score_adj,此后将替换掉/proc/<pid>/oom_adj。即使当前是对/proc/<pid>/oom_adj进行的设置,在内核内部进行变换后的值也是针对/proc/<pid>/oom_score_adj设置的。可以参见 feature-removal-schedule 这里 171行。

/proc/$pid/oom_score

This file can be used to check the current score used by the oom-killer is for
any given <pid>. Use it together with /proc/<pid>/oom_score_adj to tune which
process should be killed in an out-of-memory situation.

OOM killer机制主要根据该值和 /proc/<pid>/oom_score_adj 来决定杀死哪一个进程的。分数越高,越先被kill。

通过如下命令可以查看进程 oom_score 分数情况。最后一列是分数。

# ps -eo pid,command,pmem --sort -rss | awk '{"cat /proc/"$1"/oom_score" | getline oom; print $0"\t"oom}'
cat: /proc/PID/oom_score: No such file or directory
  PID COMMAND                     %MEM
 7663 python ./executor.py vsSche  2.2  794
 7675 python ./executor.py vsSche  2.1  683
 7671 python ./executor.py vsSche  2.1  780
 7811 python ./executor.py vsreso  0.1  1873
 7816 python ./executor.py vsreso  0.1  1877
 7465 python ./dispatcher.py host  0.1  15
 7540 python ./executor.py vnc_au  0.0  1914

其中有一个很低的进程才 15 分,看了下是一个常驻周期性的任务进程,执行的CPU时间非常长,所以算法把该进程的分数设置的非常低。 而经常被kill的进程分数有1900+分,所以这类进程老是被kill。

防止进程不被kill

通过上文说的,一般通过 /proc/<pid>/oom_score_adj设置一个很低的分数,例如 -1000 分永远不被杀死。

当系统认为进程都无法被杀死后,内核就会panic,然后整个机器挂了。

sigkill 信号无法被捕获

日志中记录了 SIGNTERM(15),但是在 SIGNKILL(9)时却没有打印,如果有一个 SIGNKILL 的信号,那么看日志的时候也会有一个更直观的线索。

两者区别:

  • SIGNKILL(9) 的效果是立即杀死进程. 该信号不能被阻塞, 处理和忽略。

  • SIGNTERM(15) 的效果是正常退出进程,退出前可以被阻塞或回调处理。并且它是Linux缺省的程序中断信号。

The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.

不过SIGKILL无法在进程里面被捕获。在Python中会直接跑出一个异常,所以无法打印这个信号。

>>> import signal
>>> def trycache(*args):
...     print args
...
>>> signal.signal(signal.SIGKILL,trycache)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: (22, 'Invalid argument')

阻止内存泄漏方法

很多程序会跑着跑着然后内存就泄漏了,然后内存就OOM。

特别的,像Python 虚拟机这样的程序,就申请了内存后,就不会释放内存给系统,会一直在虚拟机内部进行使用。那么对待这类程序的内存泄漏最好的方法是什么呢?

周期性reload进程。

是的,就是这么暴力,这么直接。

之前看 uWSGI里有个参数max-requests在处理了一定次数的请求后,会自动reload该进程。这样可以防止该进程的内存泄漏。

像平台类的软件,能做的就是在外部周期性reload进程。而业务的编写者,就得控制好自己进程的内存管理了。

不过要支持一个能reload进程的服务(注意不是restart),这个是一个要求需要比较高能力。幸好大部分的CGI进程都支持reload,例如nginx、php-fpm、uWSGI等。

而一个后台批量型任务,做到restart就行了,毕竟对进程重启对间隙不太敏感。做负载均衡的话,推荐用MQ可以推送给还能处理任务的进程。

自动补充进程

发现一些OOM的被kill的进程,比如 nslcd 进程,不断的被kill,但是会不断给补充进来。因此我们的进程管理设置,也需要增加一些进程自动补充,这样防止进程被oom几天都不知道。这样可以达到变相reload。

参考

关于python捕获内核发出的sigkill信号问题

https://learning-kernel.readthedocs.io/en/latest/mem-management.html

声明:未经允许禁止转载 东东东 陈煜东的博客 文章,谢谢。如经授权,转载请注明: 转载自东东东 陈煜东的博客

本文链接地址: 进程不见了,Linux 的OOM Killer – https://www.chenyudong.com/archives/linux-oom-killer.html

分类: Linux

wget 下载整个网页和css、js、图片数据

想要抓取网站的一个页面,包括css、图片、js的文件,用 Chrome、FireFox 去另存为成网页不行,有些数据不能下载下来。

wget 就可以下载网页及其依赖

# 这个可以将整个页面下载下来。
wget -l 1 -p -np -k http://www.domain.com/page.html
# 可以抓取整站
wget -c -r -nd -np -k -L -p http://www.domain.com

wget 参数

-V 版本信息
-h 帮助信息
-b 后台执行Wget
-o filename 把记录放在文件filename
-a filename 把记录附加在文件filename
-d 显示调试信息
-q 无输出下载方式
-v 详细的屏幕输出(默认)
-nv 简单的屏幕输出
-i inputfiles 从文本文件内读取地址列表
-F forcehtml 从html文件内读取地址列表
-t number number次重试下载(0时为无限次)
-O output document file 写文件到文件
-nc 不覆盖已有的文件
-c 断点下传
-N 时间时间戳。该参数指定wget只下载更新的文件,也就是说,与本地目录中的对应文件的长度和最后修改日期一样的文件将不被下载。
-S 显示服务器响应
-T timeout 超时时间设置(单位秒)
-w time 重试延时(单位秒)
-Y proxy=on/off 是否打开代理
-Q quota=number 重试次数

目录:
-nd –no-directories 不建立目录。
-x, –force-directories 强制进行目录建立的工作。
-nH, –no-host-directories 不建立主机的目录。
-P, –directory-prefix=PREFIX 把档案存到 PREFIX/…
–cut-dirs=NUMBER 忽略 NUMBER 个远端的目录元件。

HTTP 选项:
–http-user=USER 设 http 使用者为 USER.
–http0passwd=PASS 设 http 使用者的密码为 PASS.
-C, –cache=on/off 提供/关闭快取伺服器资料 (正常情况为提供).
–ignore-length 忽略 `Content-Length’ 标头栏位。
–proxy-user=USER 设 USER 为 Proxy 使用者名称。
–proxy-passwd=PASS 设 PASS 为 Proxy 密码。
-s, –save-headers 储存 HTTP 标头成为档案。
-U, –user-agent=AGENT 使用 AGENT 取代 Wget/VERSION 作为识别代号。
FTP 选项:
–retr-symlinks 取回 FTP 的象徵连结。
-g, –glob=on/off turn file name globbing on ot off.
–passive-ftp 使用 “passive” 传输模式。

使用递回方式的取回:
-r, –recursive 像是吸入 web 的取回 — 请小心使用!.
-l, –level=NUMBER 递回层次的最大值 (0 不限制).
–delete-after 删除下载完毕的档案。
-k, –convert-links 改变没有关连的连结成为有关连。
-m, –mirror 开启适合用来映射的选项。
-nr, –dont-remove-listing 不要移除 `.listing’ 档。

递回式作业的允许与拒绝选项:
-A, –accept=LIST 允许的扩充项目的列表
. -R, –reject=LIST 拒绝的扩充项目的列表。
-D, –domains=LIST 允许的网域列表。
–exclude-domains=LIST 拒绝的网域列表 (使用逗号来分隔).
-L, –relative 只跟随关联连结前进。
–follow-ftp 跟随 HTML 文件里面的 FTP 连结。
-H, –span-hosts 当开始递回时便到外面的主机。
-I, –include-directories=LIST 允许的目录列表。
-X, –exclude-directories=LIST 排除的目录列表。
-nh, –no-host-lookup 不透过 DNS 查寻主机。
-np, –no-parent 不追朔到起源目录。

参考链接

声明:未经允许禁止转载 东东东 陈煜东的博客 文章,谢谢。如经授权,转载请注明: 转载自东东东 陈煜东的博客

本文链接地址: wget 下载整个网页和css、js、图片数据 – https://www.chenyudong.com/archives/wget-download-html-and-image-css.html

分类: Diary

Android、IOS 手机扫描家庭二维码连接 WiFi

在家里亲朋好友来,通过扫描 WiFi 二维码来进行连接家里的 WiFi,不用通过输入密码的方法,这是及其方便的事情。

适用平台

  • Android 手机的系统自带相机
  • Android 系统自带的扫一扫
  • Android 系统上浏览器自带的扫一扫
  • 支持常见的华为、小米、oppo、vivo等安卓系统
  • 苹果 iOS 11 及其以上系统自带相机(iOS 9、iOS 10 不支持)
  • iPhone 6手机如果升级到iOS 11可能会很卡,慎重升级

生成 WiFi 二维码

试验过很多在线 WiFi 二维码的生成软件,很多生成的二维码有问题,支持的手机不过多。有的时候很奇怪。为啥有的手机能连接这个 WiFi,iOS 11的手机就不支持呢。

qrcode-wifi

我试过不同的平台生成二维码,仔细对比,发现每个平台生成的二维码不一样。最后找到了一个适用于 Android 和 iOS 的 WiFi 二维码的序列号。如下:

WIFI:T:WPA;S:wifiname;P:wifipasswd;;

说明一下:

  • WIFI 表示这个是一个连接 WiFi 的协议
  • S 表示后面是 WiFi 的 SSID,wifiname 也就是 WiFi 的名称
  • P 表示后面是 WiFi 的密码,wifipasswd 是 WiFi 的密码
  • T 表示后面是密码的加密方式,WPA/WPA2 大部分都是这个加密方式,也使用WPA。如果写WPA/WPA2我的小米手机无法识别。
  • H 表示这个WiFi是否是隐藏的,直接打开 WiFi 扫不到这个信号。苹果还不支持隐藏模式

二维码通过 https://cli.im/text 这个平台生成,文本信息内容如上,可适用于Android、苹果等系统。

扫一扫结果展示

qrcode-wifi-scan-result

各家手机如何使用扫一扫连WiFi

苹果

打开系统自带相机

小米

打开系统自带相机

华为

系统自带相机无法识别。需要主屏下滑,左上角搜索有个二维码扫一扫。

华为手机使用扫一扫

家里是否可以使用微信连WiFi

不可行。

考虑家里的长辈来家里,一般都装有微信,也习惯使用微信的扫一扫。但是却无法通过微信的扫一扫去连接WiFi。

微信扫一扫直接出来的是文本,无法让系统自动连接上WiFi。

以后微信是否会支持该功能不好说。毕竟苹果还不开放第三方的这个连功能。

那么在商店中经常看见有微信的连WiFi的功能,那个是怎么做到的呢?

这个是需要商店开通微信公众账号,并且必须要使用商户版本的公众账号,普通个人的公众账号是无法开通微信联WiFi的功能的。

另外路由器也是需要支持该功能的才行,现在很多的路由器也都会支持这个插件,例如TP-link的一些说明书上也有说。

对个人家庭来说注册非个人公众账号比较麻烦,所以这个使用微信连WiFi 的思路就放弃了。

声明:未经允许禁止转载 东东东 陈煜东的博客 文章,谢谢。如经授权,转载请注明: 转载自东东东 陈煜东的博客

本文链接地址: Android、IOS 手机扫描家庭二维码连接 WiFi – https://www.chenyudong.com/archives/wifi-qrcode-in-home-android-and-ios.html

分类: 实用技巧

Copyright © 2019 东东东 陈煜东的博客 粤ICP备13059639号-1

SITEMAP回到顶部 ↑