BMF源码分析（四）

源码如下：
Graph初始化时根据inputstream的identifier_和outputstream的identifier_确认流关系：

// create connections
for (auto &node_iter : nodes_) {
std::map<int, std::shared_ptr> output_streams;
node_iter.second->get_output_streams(output_streams);
// find all downstream connections for every output stream
for (auto &output_stream : output_streams) {
add_all_mirrors_for_output_stream(output_stream.second);
}
}

当两个node之间node1的output_stream的identifier_和node2的input_steams的identifier_相同时确认镜像流关系

int Graph::add_all_mirrors_for_output_stream(
    std::shared_ptr<OutputStream> &output_stream) {
    // go through all the nodes, find the input stream that
    // connected with graph input stream, add it to mirrors
    for (auto &node_iter : nodes_) {
        if (not node_iter.second->is_source()) {
            std::shared_ptr<InputStreamManager> input_stream_manager;
            node_iter.second->get_input_stream_manager(input_stream_manager);
            for (auto &input_stream : input_stream_manager->input_streams_) {
                if (output_stream->identifier_ ==
                    input_stream.second->identifier_) {
                    output_stream->add_mirror_stream(input_stream_manager,
                                                     input_stream.first);
                    input_stream.second->set_connected(true);
                }
            }
        }
    }
    return 0;
}

镜像流源码如下：

MirrorStream::MirrorStream(
    std::shared_ptr<InputStreamManager> input_stream_manager, int stream_id)
    : input_stream_manager_(input_stream_manager), stream_id_(stream_id) {}

OutputStream::OutputStream(int stream_id, std::string const &identifier,
                           std::string const &alias, std::string const &notify)
    : stream_id_(stream_id), identifier_(identifier), alias_(alias),
      notify_(notify) {}

int OutputStream::add_mirror_stream(
    std::shared_ptr<InputStreamManager> input_stream_manager, int stream_id) {
    mirror_streams_.emplace_back(MirrorStream(input_stream_manager, stream_id));
    return 0;
}

InputStreamManager往task中填写packet报文：

bool ImmediateInputStreamManager::fill_task_input(Task &task) {
    bool task_filled = false;
    for (auto &input_stream : input_streams_) {
        if (input_stream.second->is_empty()) {
            //            task.fill_input_packet(iter->second->get_id(),
            //            Packet());
            continue;
        }

        while (not input_stream.second->is_empty()) {
            Packet pkt = input_stream.second->pop_next_packet(false);
            if (pkt.timestamp() == BMF_EOF) {
                if (input_stream.second->probed_) {
                    BMFLOG(BMF_INFO)
                        << "immediate sync got EOF from dynamical update";
                    pkt.set_timestamp(DYN_EOS);
                    input_stream.second->probed_ = false;
                } else
                    stream_done_[input_stream.first] = 1;
            }
            task.fill_input_packet(input_stream.second->get_id(), pkt);
            task_filled = true;
        }
    }

    if (stream_done_.size() == input_streams_.size()) {
        task.set_timestamp(BMF_EOF);
    }
    return task_filled;
}

OutputStreamManager将task放入下一个node节点的inputstream中

int OutputStreamManager::post_process(Task &task) {
    for (auto &t : task.outputs_queue_) {
        auto q = std::make_shared<SafeQueue<Packet>>(t.second);
        output_streams_[t.first]->propagate_packets(q);
    }
    return 0;
}

int OutputStream::propagate_packets(
    std::shared_ptr<SafeQueue<Packet>> packets) {
    for (auto &s : mirror_streams_) {
        auto copy_queue = std::make_shared<SafeQueue<Packet>>(*packets.get());
        copy_queue->set_identifier(identifier_);
        s.input_stream_manager_->add_packets(s.stream_id_, copy_queue);
    }
    return 0;
}