建模杂谈系列211 ADBS的取数模式以及衔接

本文链接：https://blog.csdn.net/yukai08008/article/details/129381384

文章详细阐述了ADBS（一种基于Mongo和Redis的数据库流转体系）的工作模式，特别是Sniffer在数据取数场景中的作用。Sniffer用于从数据库或ADBS内部取数，处理高并发任务。文中提出了简化Sniffer取数流程的方案，通过限制只有一个Sniffer取数，减少了复杂性和超时重试的问题。此外，文章还探讨了如何优化队列管理，确保并发处理的效率，并提供了相关的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

说明

这应该是进一步的完善ADBS的工作模式。

之所以做A系列的架构工具，就是为了可以实现大型的数据处理、存储。从应用上说，是为了提高效率，并达到超高的效果。

为了达到这个目的，就必须从数据架构上、任务调度上、逻辑架构上作出好的设计，并将之实现。逻辑架构主要对应的就是Core的设计，目前初步的实现了ETL，模型的还没有去实现，但有了Core和ETL的经验，那么模型只是另一种形态和时间问题。

但无论如何，数据架构一定是所有应用的基础，所以第一步也就是实现了数据架构。ADBS是基于Mongo和Redis搭建的一套可适应高并发并支持多Worker并行执行的数据库流转体系，目前看来效果是很理想的，单核日吞吐可以达到3000万条数据以上。

因为单步的ADBS已经包含了包括流转、监控、分发在内的一系列程序(sniffer, io型)，单个ADBS已经具备了很强的独立服务能力，而如果要进行定制化修改会略显麻烦。所以从应用于结构可靠性的角度上考虑，我倾向于使用「简单结构，多层迭代」。这也是从计算机发展史里得到的教训，简单的结构（迭代/叠加）才可能实现真正复杂的功能。

本次的内容就是在进行ADBS之间连接时，sniffer的动作。

内容

1 Sniffer的取数场景

广义上来说，ADBS里除了Worker，其他都是Sniffer。不过这里特指进行取数衔接的程序部分。

我大致想了一下，Sniffer可能有几个取数场景：

1 从数据库取数。这在之前的项目服务类场景下常见，需要我向数据库发起Range或者Set查询，来获取要处理的数据。
2 文件取数。例如这次，我会手动下载510300的离线文件，然后由Sniffer驱动取到第一个ADBS
3 ADBS取数。也就是本次讨论的内容，从ADBS取数。本质上也是从数据库取数，但是由于ADBS存在一些规范，所以取数的模式可以比较固定。另外就是未来ADBS之间衔接必然是不可少的一部分，所以特殊独立出来。

2 取数模式

某个step_out的数据如下
在这里插入图片描述
step_out提供了默认的任务通道_ch001，在sniffer取数时需要根据这个通道的状态进行查询、ACK。

一般情况下，Sniffer取数后要立即ACK状态1，这样避免其他Sniffer重复的获取数据；在最后一步的时候ACK2或者3表示任务的完成状态。有时候，数据不满足条件，这样会导致计算失败。此时会有再次巡查Sniffer，检查到超时会将任务重启初始化。当然，超时重试也有次数限制。

初次请求：

1 请求数据【是否为空】【是否满足可用条件】
2 * 回应【ACK】【如果是数据库取数】
3 根据规则判断下一步可行性【队列是否溢出】
4 执行具体操作【增删改】
5 进行回应【ACK】【异常上报】

再次巡查：

1 检查数据是否认领+超时
2 将数据的通道字段翻回0

在这里加入一个限定：只有一个Sniffer向Step Out(Mongo)发起取数。

加入这个限定后，请求过程会得到简化，但是这样合理吗？

在ADBS中，任务的分发是通过Redis的Stream完成的，天然的分发方式。所以Sniffer的这个变化不影响并发处理。

并且对于IO来说，单个Sniffer可以吞吐的速度已经足够快了。每秒1万条就已经超过单核ADBS一天吞吐量的好几倍了。

所以，结论是可行。

加入限定后，流程变得简单：

1 请求数据
- 执行两个判定：数据是否为空、数据是否满足特定要求(基础要求)
2 判断目标队列是否会溢出
3 根据2的结果决定是否执行操作
4 根据3的结果决定是否ACK

这样就不用考虑并行时的抢占，也不必考虑考虑巡检重置超时的问题。

具体的做法其实可以参考StreamsIO.M2S的方法，当时只是考虑在本ADBS中将Mongo数据拉到工作队列并记录日志。现在的差别是读取数据和日志不是同一个ADBS。

实例：

这个Sniffer运行在MyQuantBaseStep2Signals，向MyQuantBase.step1_mongo_out发起取数。

1 Sniffer实际运行的ADBS是MyQuantBaseStep2Signals。
2 Sniffer请求的源是MyQuantBase.step1_mongo_out
3 Sniffer记录的log是在MyQuantBaseStep2Signals
4 Sniffer的目标是 MyQuantBaseStep2Signals.

需要的一些参数

1 redis服务地址
2 超时设置
3 批次取数量
4 源mongo的tier1和tier2
5 当前mongo记录日志的tier1和tier2
6 当前所使用的通道
7 目标队列的最大长度

代码：

from funcs_apifunc_database_model1_6810f9d37e89e5e1f33e1b8f4defa22e import *

from configs_base import redis_agent_host,project_name,cur_w
from configs_base import color_print,step1_stream_in


# 判断队列是否可以插入
def is_q_available(stream_name, maxlen = 100000, 
                    new_task_len = 10000, 
                    redis_agent = None,connection_hash =None  ):
    cur_redis_agent = redis_agent
    cur_len_resp = req.post(cur_redis_agent + 'len_of_queue/',
                            json ={'stream_name':stream_name,
                               'connection_hash':connection_hash}).json()

    if cur_len_resp['status']:
        cur_len = cur_len_resp['data']
        if cur_len + new_task_len >=maxlen:
            return False 
        else:
            return True 
    else:
        print('Connection Error')
        return False 

#  基于并发方法，向数据库存数【队列Write相关-写入消息】- 其实是使用pipeline - 最好单次一万左右
def parrallel_write_msg(stream_name, data_listofdict = None ,maxlen = None, time_out = None,
                                redis_agent = None,connection_hash =None,is_return_msg_id_list=False):
    cur_redis_agent = redis_agent
    cur_maxlen = maxlen or 100000
    # 默认十秒超时
    time_out = time_out or 30
    print('>>> 并发写Stream')
    tick11 = time.time()
    resp_dict = req.post(cur_redis_agent + 'batch_add_msg/',json ={'connection_hash':connection_hash,
                                                                'stream_name':stream_name,
                                                                'msg_dict_list':data_listofdict,
                                                                'maxlen':cur_maxlen,
                                                                'is_return_msg_id_list':is_return_msg_id_list},
                                                        timeout=time_out).json()
    tick13 = time.time()
    print('写入任务数据 {:.2f}'.format(tick13 -tick11))

    return resp_dict

# 回应
def ack_mongo(w =  None,tier1 = None, tier2 = None, key_list = None,
                    keyname = None, channel_name = None, channel_val = None ):
    cur_w = w or self.w 
    var_list =[tier1, tier2, key_list, keyname, channel_name, channel_val]
    assert all(var_list), ','.join(var_list)+'参数不可为空'
    filter_list =  [{keyname:{'$in':key_list}}]
    attr_list = [{channel_name:channel_val}]
    inc_list = [{channel_name+ '_cnt': 1}]
    return cur_w.update_with_inc(tier1 = tier1, tier2 = tier2, filter_list= filter_list, 
                            attr_list = attr_list, inc_list = inc_list)


# ============== Modify 2023.01.10
# 【基础定义区-常变】
cur_machine = get_machine_name()
print('Current Machine', cur_machine)

redis_agent_host = 'http://172.17.0.1:24021/'
redis_connection_hash =None

# 这个sniffer盯的是上一个ADBS的输出
# source 
source_server = 'm7.24065'
source_tier1 = 'MyQuantBase'
source_tier2 = 'step1_mongo_out'
gs_id = 'rec_id'

current_tier1 = project_name


market = 'SH'
code ='510300'
start_slot = 26299291

# 这个可以自由定义，这里我用了24000最大周期 + 之前有一部分误写入的部分
burnt_slots = 20000
batch_num = 10000
# 目标队列允许的最大长度
target_q_max_len = 100000
target_q_name = '%s.%s' % (current_tier1, step1_stream_in)
sniffer_name = 'sniffer01_query_step1_result'
keyname = gs_id
channel_name = '_ch001'
custom_filter_list = [{'market':market,'code':code}]
default_filter_list =  [{'_is_enable':1, channel_name:0}]
# 数据连接操作不得超过30秒
db_connect_ttl = 30

try:
    source_w = from_pickle('source_w_' + source_tier1)
    color_print('【Loading source_w】from pickle')
except:
    w = WMongo('w')
    source_w = w.TryConnectionOnceAndForever(server_name =source_server)
    to_pickle(source_w, 'source_w_' +source_tier1)






# ============================  操作
msg =''
log_tier1 = current_tier1
log_tier2 = 'log_sniffer'

tick1 = time.time()

# 判断队列是否可以写入
is_target_q_available = is_q_available(target_q_name,maxlen = target_q_max_len, 
                                        new_task_len = batch_num, 
                                        redis_agent = redis_agent,
                                        connection_hash =redis_connection_hash)

cur_len_resp = req.post(redis_agent + 'len_of_queue/',
                        json ={'stream_name':target_q_name,'connection_hash':redis_connection_hash}).json()

q_len = cur_len_resp['data']
print('{} Q has {} Messages' .format(target_q_name,q_len))

# 如果目标队列满
if not is_target_q_available:
    msg = 'target q is full {} ,{}'.format(q_len, qname)



if is_target_q_available:
    tick100 = time.time()
    color_print('>>> fetching from Mongo ')
    recs = source_w.query_recs(tier1 = source_tier1, 
                               tier2 = source_tier2, 
                               filter_dict= {'$and':default_filter_list + custom_filter_list}, 
                        silent=True, limits = batch_num, sort_tuple_list=[(channel_name,1)])
    print('Spends {:.2f}' .format(time.time()-tick100))
    rec_num =  len(recs['data'])
    if rec_num:
        data_listofdict = recs['data']

        tick101 = time.time()
        color_print('>>> Writing To Stream ')

        write_resp = parrallel_write_msg(target_q_name, data_listofdict = data_listofdict ,
                                        maxlen = target_q_max_len, time_out = db_connect_ttl,
                                        redis_agent = redis_agent,connection_hash =redis_connection_hash, 
                                        is_return_msg_id_list=True)

        print('Spends {:.2f}' .format(time.time()-tick101))
        # 假设全部成功，如果有失败的最终会被发现超时
        successful_keyname = list(pd.DataFrame(data_listofdict)[keyname])   
        # ack - 成功
        ack_res = ack_mongo( w =  source_w,tier1 = source_tier1 , 
                    tier2 = source_tier2, key_list =successful_keyname ,
                    keyname = keyname, channel_name = channel_name, channel_val = 2 )
        
        if ack_res['status']:
            msg ='ok,{} of {} , {}'  .format(len(successful_keyname),rec_num, target_q_name)

        else:
            msg ='error,ack mongo {} recs of {}' .format(rec_num, target_q_name)

    else:
        msg ='no source data {}' .format(target_q_name)

tick2 = time.time()
duration = round(tick2 -tick1,2)
# -- log
log_dict = {'sniffer': sniffer_name,'duration':duration,'msg': msg }

cur_w.insert_recs(tier1=log_tier1, tier2=log_tier2, data_listofdict =[log_dict])
# ============================  操作 END