Client客户端模块

于 2024-08-31 11:58:46 发布
阅读量133 收藏 2
点赞数 5
分类专栏： MQ项目 文章标签： 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzfnb666/article/details/141750630
版权

一.Client模块介绍

二.Client具体实现

1.消费者/订阅者模块

2.信道管理模块

3.异步线程模块

4.连接管理模块

这个模块同样是针对muduo库客户端连接的二次封装，向用户提供创建channel信道的接口，创建信道后，可以通过信道来获取指定服务。

三.全部代码

consumer.hpp

#pragma once
#include "../common_mq/helper.hpp"
#include "../common_mq/logger.hpp"
#include "../common_mq/msg.pb.h"
#include <unordered_map>
#include <mutex>
#include <memory>
#include <cassert>
#include <cstring>
#include <vector>
#include <functional>
namespace mq
{
    // tag  BasicAttributes body
    using ConsumerCallBack = std::function<void(const std::string &, const msg::BasicAttributes *, const std::string &)>;
    struct Consumer
    {
        using ptr = std::shared_ptr<Consumer>;

        std::string _tag;     // 消费者标识
        std::string _qname;   // 订阅的队列的名称
        bool _auto_ack;       // 是否自动确认
        ConsumerCallBack _cb; // 消费者回调函数
        Consumer(const std::string &ctag, const std::string &qname, bool auto_ack, const ConsumerCallBack &cb)
            : _tag(ctag), _qname(qname), _auto_ack(auto_ack), _cb(cb)
        {
            DLOG("consumer:%s created %p", ctag.c_str(), this);
        }
        Consumer()
        {
            DLOG("consumer created %p", this);
        }
        ~Consumer()
        {
            DLOG("consumer destroyed %p", this);
        }
    };
};

channel.hpp

#pragma once
#include "../common_mq/helper.hpp"
#include "../common_mq/logger.hpp"
#include "../common_mq/msg.pb.h"
#include "../common_mq/myproto.pb.h"
#include <string>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <cassert>
#include <cstring>
#include "muduo/net/TcpConnection.h"
#include <condition_variable>
#include "consumer.hpp"
#include "proto/codec.h"
#include "../common_mq/myproto.pb.h"

namespace mq
{
    using BasicConsumeRspPtr = std::shared_ptr<msg::BasicConsumeRsp>;
    using BasicCommonResponsePtr = std::shared_ptr<msg::BasicCommonResponse>;
    using ProtobufCodecPtr = std::shared_ptr<ProtobufCodec>;
    class Channel
    {
    private:
        std::string _chid;                                                        // 信道ID
        Consumer::ptr _consumer;                                                  // 消费者对象
        muduo::net::TcpConnectionPtr _conn;                                       // 连接对象
        ProtobufCodecPtr _codec;                                                  // 编解码器
        std::mutex _mutex;                                                        // 互斥锁
        std::condition_variable _cv;                                              // 条件变量
        std::unordered_map<std::string, BasicCommonResponsePtr> _consume_rsp_map; // 存放常规响应的map

    public:
        using ptr = std::shared_ptr<Channel>;

        Channel(const muduo::net::TcpConnectionPtr &conn,
                const ProtobufCodecPtr &codec)
            : _conn(conn), _codec(codec)
        {
            _chid = UUIDHelper::uuid();
            DLOG("channel:%s created", _chid.c_str());
        }
        Channel()
        {
        }
        ~Channel()
        {
            basicCancel();
            DLOG("channel:%s destroyed", _chid.c_str());
        }
        std::string chid() const
        {
            return _chid;
        }

        // 发送请求，在服务器端处理请求，创建相应的数据结构对象
        // 1. 声明/删除/查找交换机
        bool declareExchange(const std::string &name, msg::ExchangeType type,
                             bool durable,
                             bool auto_del,
                             google::protobuf::Map<std::string, std::string> &args)
        {
            // 构建请求
            msg::DeclareExchangeReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_e_name(name);
            req.set_e_type(type);
            req.set_durable(durable);
            req.set_auto_delete(auto_del);
            req.mutable_args()->swap(args);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("declare exchange failed, name:%s", name.c_str());
                return false;
            }
            return true;
        }
        bool removeExchange(const std::string &name)
        {
            // 构建请求
            msg::RemoveExchangeReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_e_name(name);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("remove exchange failed, name:%s", name.c_str());
                return false;
            }
            return true;
        }
        // 2. 声明/删除队列
        bool declareQueue(const std::string &name, bool durable,
                          bool exclusive, bool auto_del,
                          google::protobuf::Map<std::string, std::string> &args)
        {
            // 构建请求
            msg::DeclareQueueReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_q_name(name);
            req.set_durable(durable);
            req.set_exclusive(exclusive);
            req.set_auto_delete(auto_del);
            req.mutable_args()->swap(args);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("declare queue failed, name:%s", name.c_str());
                return false;
            }
            return true;
        }
        bool removeQueue(const std::string &name)
        {
            // 构建请求
            msg::RemoveQueueReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_q_name(name);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("remove queue failed, name:%s", name.c_str());
                return false;
            }
            return true;
        }

        // 3. 绑定/解绑
        bool bind(const std::string &ename, const std::string &qname, const std::string &key)
        {
            // 构建请求
            msg::BindReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_e_name(ename);
            req.set_q_name(qname);
            req.set_bind_key(key);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("bind failed, ename:%s, qname:%s, key:%s", ename.c_str(), qname.c_str(), key.c_str());
                return false;
            }
            return true;
        }
        bool unbind(const std::string &ename, const std::string &qname)
        {
            // 构建请求
            msg::UnbindReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_e_name(ename);
            req.set_q_name(qname);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("unbind failed, ename:%s, qname:%s", ename.c_str(), qname.c_str());
                return false;
            }
            return true;
        }
        // 4. 订阅/取消订阅
        bool basicSubscribe(const std::string &qname, const std::string &consumer_tag, bool auto_ack, const ConsumerCallBack &cb)
        {
            if (_consumer.get() != nullptr)
            {
                ELOG("channel has consumer, qname:%s, consumer_tag:%s", qname.c_str(), consumer_tag.c_str());
                return false;
            }

            // 构建请求
            msg::BasicSubscribeReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_q_name(qname);
            req.set_consumer_tag(consumer_tag);
            req.set_auto_ack(auto_ack);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("basic subscribe failed, qname:%s, consumer_tag:%s", qname.c_str(), consumer_tag.c_str());
                return false;
            }
            // 注册消费者
            _consumer = std::make_shared<Consumer>(consumer_tag, qname, auto_ack, cb);
            return true;
        }
        void basicCancel()
        {
            if (_consumer.get() == nullptr)
            {
               // DLOG("不是消费者信道，不需要取消订阅");
                return;
            }
            // 构建请求
            msg::BasicCancelReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_consumer_tag(_consumer->_tag);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("basic cancel failed, consumer:%s", _consumer->_tag.c_str());
                return;
            }
            // 注销消费者
            _consumer.reset();
            return;
        }
        // 5. 消息的发布，确认
        bool basicPublish(const std::string &ename, msg::BasicAttributes *bp, const std::string &body)
        {
            // 构建请求
            msg::BasicPublishReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_e_name(ename);
            req.set_body(body);
            if (bp != nullptr)
            {
                req.mutable_attr()->CopyFrom(*bp);
            }
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("basic publish failed, qname:%s", ename.c_str());
                return false;
            }
            return true;
        }

        void basicAck(const std::string &id)
        {
            if (_consumer.get() == nullptr)
            {
                ELOG("channel has no consumer, qname:%s, id:%s", _consumer->_qname.c_str(), id.c_str());
                return;
            }
            // 构建请求
            msg::BasicAckReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            req.set_q_name(_consumer->_qname);
            req.set_messagg_id(id);
            // 发送请求
            _codec->send(_conn, req);
            // 异步操作，需要等待响应

            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            if (rsp->success() != true)
            {
                ELOG("basic ack failed, qname:%s, id:%s", _consumer->_qname.c_str(), id.c_str());
                return;
            }
            return;
        }

        // 6.打开/关闭信道
        bool openChannel()
        {
            msg::OpenChannelReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            if(_codec.get() == nullptr)
            {
                ELOG("codec is null");
                return false;
            }
            _codec->send(_conn, req);
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            return rsp->success() == true;
        }
        void closeChannel()
        {
            msg::CloseChannelReq req;
            req.set_rid(UUIDHelper::uuid());
            req.set_chid(_chid);
            _codec->send(_conn, req);
            BasicCommonResponsePtr rsp = waitResponse(req.rid());
            return;
        }

    private:
        // 等待服务端响应
        BasicCommonResponsePtr waitResponse(const std::string &req_id)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cv.wait(lock, [this, &req_id]()
                     { return _consume_rsp_map.find(req_id) != _consume_rsp_map.end(); });
            BasicCommonResponsePtr rsp = _consume_rsp_map[req_id];
            _consume_rsp_map.erase(req_id);
            return rsp;
        }

    public:
        // 给连接对象提供的函数，收到来自服务器不同类型的消息，进行不同的处理
        // 收到通用响应，向map中添加响应
        void putBasicCommonResponse(const BasicCommonResponsePtr &rsp)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _consume_rsp_map[rsp->rid()] = rsp;
            _cv.notify_all();
        }
        // 收到来自服务器的消费响应，调用消费者的回调函数
        void consume(const BasicConsumeRspPtr &rsp)
        {
            if (_consumer.get() == nullptr)
            {
                ELOG("channel has no consumer");
                return;
            }
            if (_consumer->_tag != rsp->consumer_tag())
            {
                ELOG("consumer tag not match, consumer_tag:%s", _consumer->_tag.c_str());
                return;
            }
            _consumer->_cb(rsp->consumer_tag(), rsp->mutable_attr(), rsp->body());
        }
    };

    class ChannelManager
    {
    private:
        std::unordered_map<std::string, mq::Channel::ptr> _channels; // 信道管理器
        std::mutex _mutex;                                           // 互斥锁
    public:
        using ptr = std::shared_ptr<ChannelManager>;
        ChannelManager() {}

        Channel::ptr create(const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto channel = std::make_shared<mq::Channel>(conn, codec);
            _channels.insert(std::make_pair(channel->chid(), channel));
            return channel;
        }
        void remove(const std::string &chid)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _channels.erase(chid);
            //DLOG("erase channel:%s", chid.c_str());
        }
        Channel::ptr get(const std::string &chid)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _channels.find(chid);
            if (it == _channels.end())
            {
                return Channel::ptr();
            }
            return it->second;
        }
    };
};

async_worker.hpp

#pragma once
#include <memory>
#include "../common_mq/thread_pool.hpp"
#include "muduo/net/EventLoopThread.h"
#include "../common_mq/helper.hpp"
#include "../common_mq/logger.hpp"

namespace mq
{
    class AsyncWorker
    {
    public:
        using ptr = std::shared_ptr<AsyncWorker>;
        // muduo::net::EventLoopThread _loopThread;
        std::unique_ptr<muduo::net::EventLoopThread> _loopThread;
        ThreadPool _pool;

        AsyncWorker()
            : _loopThread(std::make_unique<muduo::net::EventLoopThread>())
        {
        }
    };
}

connection.hpp

#pragma once
#include "proto/codec.h"
#include "proto/dispatcher.h"

#include "../include/muduo/base/Logging.h"
#include "../include/muduo/base/Mutex.h"
#include "../include/muduo/net/TcpClient.h"
#include "../include/muduo/net/EventLoopThread.h"
#include "../include/muduo/net/TcpConnection.h"
#include "../include/muduo/base/CountDownLatch.h"
// #include "include/muduo/base/Mutex.h"
// #include "include/muduo/net/TcpClient.h"
// #include "include/muduo/net/EventLoopThread.h"
// #include "include/muduo/net/TcpConnection.h"
// #include "include/muduo/base/CountDownLatch.h"
#include <iostream>
#include <functional>
#include <string>
#include <stdio.h>
#include <unistd.h>
#include "async_worker.hpp"
#include "channel.hpp"
namespace mq
{
    using MessagePtr = std::shared_ptr<google::protobuf::Message>;

    class Connection
    {
    private:
        AsyncWorker::ptr _worker;      // 异步工作者
        muduo::CountDownLatch _latch;  // 等待连接成功，通知主线程
        muduo::net::TcpClient _client; // TCP客户端

        muduo::net::TcpConnectionPtr _conn; // TCP连接
        ProtobufDispatcher _dispatcher;     // Protobuf消息派发器
        ProtobufCodecPtr _codec;            // Protobuf编解码器

        ChannelManager::ptr _channelManager; // 信道管理器
    public:
        using ptr = std::shared_ptr<Connection>;
        Connection(const std::string &ip, uint16_t port, const AsyncWorker::ptr &worker)
            : _worker(worker),
              _client(_worker->_loopThread->startLoop(), muduo::net::InetAddress(ip, port), "Connection"),
              _latch(1),
              _dispatcher(std::bind(&Connection::onUnknownMessage, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)),
              _codec(std::make_shared<ProtobufCodec>(std::bind(&ProtobufDispatcher::onProtobufMessage, &_dispatcher, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))),
              _channelManager(std::make_shared<ChannelManager>())
        {
            _client.setConnectionCallback(std::bind(&Connection::onConnection, this, std::placeholders::_1));
            _client.setMessageCallback(std::bind(&ProtobufCodec::onMessage, _codec.get(), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

            _dispatcher.registerMessageCallback<msg::BasicConsumeRsp>(std::bind(&Connection::onBasicConsumeRspCb, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<msg::BasicCommonResponse>(std::bind(&Connection::onBasicCommonRspCb, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

            _client.connect();
            _latch.wait();
        }

        Channel::ptr openChannel()
        {
            // 创建客户端channel
            auto newchannel = _channelManager->create(_conn, _codec);
            // 在服务端也要创建channel
            bool ret = newchannel->openChannel();
            if (!ret)
            {
                ELOG("open channel failed");
                return Channel::ptr();
            }

            return newchannel;
        }
        void closeChannel(const Channel::ptr &channel)
        {
            channel->closeChannel();                  // 关闭服务端channel
            std::string chid = channel->chid();
            //DLOG("remove channel: %s", chid.c_str());
            _channelManager->remove(chid); // 删除客户端channel
        }

    private:
        void onConnection(const muduo::net::TcpConnectionPtr &conn)
        {
            if (conn->connected()) // 连接成功
            {
                LOG_INFO << "Connected to " << conn->peerAddress().toIpPort();
                _conn = conn;
                _latch.countDown(); // 通知主线程连接成功，可以发送消息
            }
            else
            {
                LOG_ERROR << "Disconnected from " << conn->peerAddress().toIpPort();
                _conn.reset();
            }
        }
        void onUnknownMessage(const muduo::net::TcpConnectionPtr &conn,
                              const MessagePtr &message,
                              muduo::Timestamp time)
        {
            LOG_ERROR << "Unknown message: " << message->GetTypeName();
            conn->shutdown();
        }

    private:
        void onBasicConsumeRspCb(const muduo::net::TcpConnectionPtr &conn, const BasicConsumeRspPtr &rsp, muduo::Timestamp time)
        {
            auto channel = _channelManager->get(rsp->chid());
            if (channel.get() == nullptr)
            {
                LOG_ERROR << "channel not found: " << rsp->chid();
                return;
            }
            _worker->_pool.push([channel, rsp]
                                {
                                    channel->consume(rsp); // 封装任务，抛给线程池执行
                                });
        }
        void onBasicCommonRspCb(const muduo::net::TcpConnectionPtr &conn, const BasicCommonResponsePtr &rsp, muduo::Timestamp time)
        {
            auto channel = _channelManager->get(rsp->chid());
            if (channel.get() == nullptr)
            {
                LOG_ERROR << "channel not found: " << rsp->chid();
                return;
            }
            channel->putBasicCommonResponse(rsp); // 向map中添加响应，唤醒等待
        }
    };

};

乄北城以北乀
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP32-C3入门教程 网络篇①——TCP Socket Client 客户端应用示例
小康师兄
10-01 2691
文章目录一、前言二、快速运行三、运行效果四、程序流程4.1 主程序4.2 注册事件回调函数五、关键函数5.1 将事件回调函数注册到特定循环5.2 设置 ESP32 STA 或 AP 的配置 一、前言 Socket有两种模式 基站模式（即 STA 模式或 Wi-Fi 客户端模式），此时 ESP32-C3 连接到接入点 (AP)。 AP 模式（即 Soft-AP 模式或接入点模式），此时其他WiFi设备连接到 ESP32-C3。 本博文描述ESP32-C3作为TCP Socket Client 客户端。 二
Python3 TCP Server 服务端 Client 客户端
Leo_Huang720的博客
08-12 7356
附：&amp;amp;amp;amp;amp;官方文档：18.1. socket — Low-level networking interface — Python 3.5.6 documentation https://docs.python.org/3.5/library/socket.html
Tornado 异步服务器和客户端模块client
Dawn__Z的博客
02-19 957
一、Tornado 异步服务器和客户端模块client @tornado.gen.coroutine与yield tornado.gen.sleep(3)构建异步服务 time.sleep(5) # 同步实现 async_server.py import tornado.ioloop import tornado.web import os import time ...
JavaEE的RESTful标准技术JAX-RS，jersey-client客户端使用介绍【享学Java】
架构师：通透，才能写出好代码！
03-14 3204
在`Spring`大行其道的今天，很多人对Java的RESTful规范`JAX-RS(JSR 311)`可能比较陌生甚至未曾听闻，当然这也是能被“理解”的，毕竟Spring似乎现在已是`JavaEE`的事实标准。 现在有越来越多的公司希望能以简单而又贴合Web架构本身的方式公开Web API，因此REST变得越来越重要和流行。使用Ajax进行通信的富浏览器端也在朝这个目标不断迈进。这个架构原则提升了万维网的**可伸缩性**，无论何种应用都能从该原则中受益无穷。
ElasticSearch6.X版本Java Api中文详解（一）之TransportClient客户端连接方式
热门推荐
香菇的博客
04-20 1万+
 TransportClient使用传输模块远程连接到一个弹性搜索集群。它不加入集群，但只获得一个或多个初始传输ip地址，并在每个动作上与它们进行轮询(尽管大多数操作可能是"two hop" 操作)。// on startup TransportClient client = new PreBuiltTransportClient(Settings.EMPTY) .addTran...
Python Socket模块实现服务端与客户端通信
ASDF的博客
06-03 4229
Python Socket模块实现服务端与客户端通信
SaltStack netapi模块——Client interfaces客户端开发接口
watermelonbig的专栏
10-26 1343
Salt的客户端接口通过制作映射到函数参数的值的字典来对外暴露可执行的功能函数。 这允许仅通过创建数据结构来调用函数。 （而这也正是Salt自己内部的工作方式！） 您也可以参考在Github上维护的这一份技术资料：Client interfaces of netapi modules class salt.netapi.NetapiClient(opts) 提供一种以low-data数据结构形式访...
Nacos client 客户端cpu占用100% 问题排查和解决方案
weixin_30832983的博客
09-16 3388
Nacos version：1.1.3client version：1.0.0 dependency: 'org.springframework.cloud:spring-cloud-alibaba-nacos-config:0.9.0.RELEASE' description as below: NacosConfigService will be rebuilt every t...
python websocket 客户端_Python websocket-client 如何保持长连接呢？
weixin_39788986的博客
12-03 1321
最近在了解 websocket，但是发现死活不能保持长连接，用 tornado 实现了一个 server：# coding=utf8from tornado.websocket import WebSocketHandlerfrom tornado.web import asynchronous, Applicationfrom tornado.httpserver import HTTPServ...
基于live555的rtsp 客户端模块优化
Mtour's blog
11-14 2700
之前发布过一个基于testRtspClient.cpp 改装的 rtsp client模块
CloudClient:云数据库客户端。-开源
05-31
"CloudClient:云数据库客户端"是一款专为云环境设计的数据库访问工具，旨在简化在分布式和复杂的云架构中对数据库的管理和操作。作为一款开源软件，它的源代码可供公众查看、学习和修改，促进社区协作与技术创新。 ...
proton-python-client:Python Proton 客户端模块
08-05
质子 API Python 客户端 版权所有 (c) 2021 Proton Technologies AG 这个存储库包含 Proton Python 客户端。 有关许可信息，请参阅。 有关贡献政策，请参阅 。 描述 Python Proton 客户端适用于每个 Proton 服务...
vertx-mod-smpp-client:用于 vertx 的 SMPP 客户端模块
06-30
SMPP客户端 该模块连接到 SMPP 服务器（目前仅作为 TRANSMITTER）并发送 SMSes。...这个smpp-client模块采用以下配置： { "mode": , "address": , "host": , "port": , "username": , "password": <string
paho-mqtt客户端模块PDF
05-15
### paho-mqtt客户端模块详解 #### 概述 Paho MQTT 客户端模块是Python环境下用于实现MQTT协议的轻量级客户端库。MQTT（Message Queuing Telemetry Transport）是一种基于发布/订阅模式的轻量级消息传输协议，非常...
http-db-client:http-db 的客户端模块
06-24
这是的客户端。 安装 $ npm install --save http-db-client 用法 var Client = require ( 'http-db-client' ) ; var db = new Client ( 'http://localhost:8765' , token ) ; 有关完整的使用信息，请参阅。
并发服务器
最新发布
m0_71459026的博客
08-27 244
1.阻塞IO：fgets、scanf、read、recv、getchar。实现步骤：获取原文件描述符的属性->增加非阻塞属性->设置新属性。1.单循环服务器：同一时刻，只能处理一个客户端的任务；2.并发服务器：同一时刻，可以处理多个客户端的任务；：文件描述符，指向要进行操作的打开文件的描述符。（1）异步通知的IO方式，节省CPU；（1）实现多个IO同步的效果。，则它是要设置的值；（1）多个IO复用一个进程;（1）使用轮询的方法实现。（2）只能监测少量IO；（2）cpu占有率低。（2）cpu占有率高。
何为大模型服务器？如何明智地挑选？
HPC_Evan的博客
08-27 1109
拥有完备的 CUDA 环境、丰富多样的应用软件，如 TensorFlow、Pytorch 等，能够满足不同类型的模型训练需求，还有强大实用的函数库以及稳定可靠的 Ubuntu 22.04 LTS 64 位服务器版操作系统。对于企业而言，无论是优化生产流程的预测模型训练，还是提升客户体验的个性化推荐系统开发，这两款机型都能凭借出色的性能和稳定的运行，为企业节省时间和成本，提高市场竞争力。它们所具备的完善的软件和硬件配置，就像是为您精心打造的一把利剑，助您在大模型训练的道路上披荆斩棘，勇往直前。
服务器远程管理
m0_64827698的博客
08-26 1492
SSH两种级别的安全认证：基于口令（口令在网络上传播，易受中间人攻击），基于密钥（传公钥，公钥是否相同，公钥加密质询，私钥解密）（密钥不在网络上传）2.启用服务services.msc（telnet）/配置远程桌面服务gpedit.msc（rdp）/使⽤SSH，你可以把所有传输的数据进⾏加密，这样“中间 ⼈”这种攻击⽅式就不可能实现了。实验总结：在windows开启telnet服务（2019不支持），RDP服务，SSH。SSH协议允许⽤户通过配置⽂件⾃定义选择加密算法，以优化安全性和性能。
高防服务器中的流量清洗是什么意思？
wanhengwangluo的博客
08-27 305
高防服务器能够为企业防御一定的网络攻击，是网络游戏行业经常会选择的一款服务器类型，其中高防服务器的流量清洗则是指对服务器所接收的流量进行实时监测、识别和过滤，将恶意流量与攻击流量进行清除，保证网络能够正常运行。高防服务器还有着强大的并发处理能力，可以同时处理大量的流量请求，以此来保障网络服务的稳定性。当发现异常的流量或者是攻击行为，高防服务器能够做出实时响应，采取相应的防御措施，根据实际情况与攻击的趋势，及时调整流量过滤策略，提高防护效果，保障网络的安全。接下来我们就来探讨一下高防服务器中的流量清洗吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值