2023-简单点-proxyPool源码（三）-proxyApi.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python
"""
文件说明：
-------------------------------------------------
   File Name：     ProxyApi.py
   Description :   WebApi
   Author :       JHao
   date：          2016/12/4
-------------------------------------------------
   修改记录：
   2016/12/04: 创建WebApi
   2019/08/14: 集成Gunicorn启动方式
   2020/06/23: 新增pop接口
   2022/07/21: 更新count接口
-------------------------------------------------
"""
__author__ = 'JHao'

# 导入所需的库
import platform
from werkzeug.wrappers import Response
from flask import Flask, jsonify, request
from util.six import iteritems
from helper.proxy import Proxy
from handler.proxyHandler import ProxyHandler
from handler.configHandler import ConfigHandler

# 初始化 Flask 应用
app = Flask(__name__)
# 初始化配置处理器和代理处理器
conf = ConfigHandler()
proxy_handler = ProxyHandler()

# 自定义 JSON 响应类，用于将字典和列表自动转换为 JSON 格式
class JsonResponse(Response):
    @classmethod
    def force_type(cls, response, environ=None):
        if isinstance(response, (dict, list)):
            response = jsonify(response)  # 将字典或列表转换为 JSON 格式
        return super(JsonResponse, cls).force_type(response, environ)

# 将 Flask 的默认响应类替换为自定义的 JSON 响应类
app.response_class = JsonResponse

# 定义 API 列表，描述了可用的 API 接口及其参数和描述信息
api_list = [
    {"url": "/get", "params": "type: ''https'|''", "desc": "get a proxy"},
    {"url": "/pop", "params": "", "desc": "get and delete a proxy"},
    {"url": "/delete", "params": "proxy: 'e.g. 127.0.0.1:8080'", "desc": "delete an unable proxy"},
    {"url": "/all", "params": "type: ''https'|''", "desc": "get all proxy from proxy pool"},
    {"url": "/count", "params": "", "desc": "return proxy count"}
    # 'refresh': 'refresh proxy pool',  此行被注释掉，可能是一个未完成的功能或者已被移除的功能
]

# 定义主页路由，返回 API 列表
@app.route('/')
def index():
    return {'url': api_list}

# 定义 /get/ 路由，用于获取一个代理 IP
@app.route('/get/')
def get():
    https = request.args.get("type", "").lower() == 'https'  # 判断请求参数中的 type 是否为 'https'
    proxy = proxy_handler.get(https)  # 调用代理处理器的 get 方法获取代理 IP
    return proxy.to_dict if proxy else {"code": 0, "src": "no proxy"}  # 返回代理 IP 的字典形式，如果没有可用的代理 IP，则返回错误信息
# 定义 /pop/ 路由，用于获取一个代理 IP 并将其从代理池中移除  
@app.route('/pop/')  
def pop():  
    https = request.args.get("type", "").lower() == 'https'  # 判断请求参数中的 type 是否为 'https'  
    proxy = proxy_handler.pop(https)  # 调用代理处理器的 pop 方法获取一个代理 IP 并将其从代理池中移除  
    return proxy.to_dict if proxy else {"code": 0, "src": "no proxy"}  # 返回代理 IP 的字典形式，如果没有可用的代理 IP，则返回错误信息  
  
# 定义 /refresh/ 路由，用于刷新代理池（此功能暂未实现）  
@app.route('/refresh/')  
def refresh():  
    # TODO: 刷新操作会有守护程序定时执行，由 API 直接调用性能较差，暂不使用  
    return 'success'  # 返回成功信息  
  
# 定义 /all/ 路由，用于获取代理池中的所有代理 IP  
@app.route('/all/')  
def getAll():  
    https = request.args.get("type", "").lower() == 'https'  # 判断请求参数中的 type 是否为 'https'  
    proxies = proxy_handler.getAll(https)  # 调用代理处理器的 getAll 方法获取所有代理 IP  
    return jsonify([_.to_dict for _ in proxies])  # 返回代理 IP 列表的 JSON 形式  
  
# 定义 /delete/ 路由，用于删除指定的代理 IP  
@app.route('/delete/', methods=['GET'])  
def delete():  
    proxy = request.args.get('proxy')  # 获取请求参数中的代理 IP  
    status = proxy_handler.delete(Proxy(proxy))  # 调用代理处理器的 delete 方法删除指定的代理 IP  
    return {"code": 0, "src": status}  # 返回删除操作的结果状态  
  
# 定义 /count/ 路由，用于获取代理池中代理 IP 的统计信息  
@app.route('/count/')  
def getCount():  
    proxies = proxy_handler.getAll()  # 获取代理池中的所有代理 IP  
    http_type_dict = {}  # 用于统计 http 和 https 类型的代理 IP 数量  
    source_dict = {}  # 用于统计各种来源的代理 IP 数量  
    for proxy in proxies:  # 遍历所有代理 IP  
        http_type = 'https' if proxy.https else 'http'  # 判断代理 IP 的类型（http 或 https）  
        http_type_dict[http_type] = http_type_dict.get(http_type, 0) + 1  # 统计 http 和 https 类型的代理 IP 数量  
        for source in proxy.source.split('/'):  # 分割代理 IP 的来源字符串，并统计各种来源的代理 IP 数量  
            source_dict[source] = source_dict.get(source, 0) + 1  
    return {"http_type": http_type_dict, "source": source_dict, "count": len(proxies)}  # 返回统计信息，包括 http 和 https 类型的数量、各种来源的数量以及总数量

def runFlask():  
    # 检查当前运行的操作系统是否为 Windows  
    if platform.system() == "Windows":  
        # 如果是 Windows，则使用 Flask 自带的开发服务器来运行应用  
        app.run(host=conf.serverHost, port=conf.serverPort)  
    else:  
        # 如果不是 Windows（可能是 Linux 或 macOS），则使用 gunicorn 来运行 Flask 应用  
        import gunicorn.app.base  
  
        # 定义一个继承自 gunicorn.app.base.BaseApplication 的类，用于配置和运行应用  
        class StandaloneApplication(gunicorn.app.base.BaseApplication):  
  
            def __init__(self, app, options=None):  
                # 初始化方法，接收 Flask 应用实例和配置选项  
                self.options = options or {}  
                self.application = app  
                super(StandaloneApplication, self).__init__()  
  
            def load_config(self):  
                # 加载配置方法，将传入的配置选项转换为 gunicorn 能识别的格式，并应用到 gunicorn 的配置中  
                _config = dict([(key, value) for key, value in iteritems(self.options)  
                                if key in self.cfg.settings and value is not None])  
                for key, value in iteritems(_config):  
                    self.cfg.set(key.lower(), value)  
  
            def load(self):  
                # 加载应用方法，返回 Flask 应用实例  
                return self.application  
  
        # 定义 gunicorn 的配置选项  
        _options = {  
            'bind': '%s:%s' % (conf.serverHost, conf.serverPort),  # 绑定地址和端口  
            'workers': 4,  # 工作进程数量  
            'accesslog': '-',  # 访问日志输出到 stdout  
            'access_log_format': '%(h)s %(l)s %(t)s "%(r)s" %(s)s "%(a)s"'  # 访问日志格式  
        }  
        # 创建 StandaloneApplication 实例，并传入 Flask 应用和配置选项，然后运行应用  
        StandaloneApplication(app, _options).run()