etcd网络层(三)——stream实现过程

WhatsApp API接口的隐秘角落:从协议解析到自定义消息引擎 本文深入解析WhatsApp API接口的隐秘角落,从协议逆向工程到自定义消息引擎开发实战。通过分析WhatsApp的二进制XML协议和加密机制,构建超越官方API限制的自定义消息引擎,实现高效、灵活的即时通讯解决方案。文章还提供了企业级架构设计和风控规避策略,助力开发者突破官方限制,提升消息到达率和成本效益。 阅读详情

stream消息通道主要是通过长连接的方式和对端进行数据交互,peer结构体中的stream相关数据如下(忽略V2版本):

type peer struct {

       writer         *streamWriter   //负责向Stream消息通道中写消息

       msgAppReader   *streamReader  //负责从Stream消息通道中读消息

       .......其他字段省略

}

从中我们看到stream是读写分离的,主要有streamWriter和streamReader结构体实现相关的功能。

stream实现的相关源码在  etcdserver/api/rafthttp/stream.go文件中。

 

 

一、streamWriter

streamWriter结构体如下:

 type streamWriter struct {

       lg *zap.Logger



       localID types.ID   //本端的ID

       peerID  types.ID  //对端节点的ID



       status *peerStatus

       fs     *stats.FollowerStats

       r      Raft   //底层的Raft实例



       mu      sync.Mutex // guard field working and closer

       closer  io.Closer    //负责关闭底层的长连接

       working bool   //负责标识当前的streamWriter是否可用



       msgc  chan raftpb.Message   //Peer会将待发送的消息写入到该通道,streamWriter则从该通道中读取消息并发送出去

       connc chan *outgoingConn   //通过该通道获取当前streamWriter实例关联的底层网络连接,  outgoingConn其实是对网络连接的一层封装,其中记录了当前连接使用的协议版本,以及用于关闭连接的Flusher和Closer等信息。

       stopc chan struct{}

       done  chan struct{}

}

 

从中我们看到:

localID和peerID分别记录本端ID和对端ID

status记录当前peer的可用性状态

r 是底层的Raft实例,用于和底层的raft模块交互

closer负责关闭底层的长连接

msgc peer会将待发送到对端的消息(非快照数据)写入到该通道,streamWriter则从该通道中读取并发送到对端节点。

connc  outgoingConn其实是对网络连接的一层封装,connc用于等待对端的主动连接,当对端主动和当前节点建立连接之后,本节点才会向对端发送数据。

 

1. streamWriter的初始化

streamWriter的初始化过程在startStreamWriter函数中

func startStreamWriter(lg *zap.Logger, local, id types.ID, status *peerStatus, fs *stats.FollowerStats, r Raft) *streamWriter {

       w := &streamWriter{

              lg: lg,



              localID: local,

              peerID:  id,



              status: status,

              fs:     fs,

              r:      r,

              msgc:   make(chan raftpb.Message, streamBufSize),

              connc:  make(chan *outgoingConn),

              stopc:  make(chan struct{}),

              done:   make(chan struct{}),

       }

       go w.run()

       return w

}

 

该方法主要是用于初始化streamWriter中的相关字段,并开启一个协程执行run方法。

 

 

2.run方法

run方法是streamWriter的核心,源码如下:

func (cw *streamWriter) run() {

       var (

              msgc       chan raftpb.Message   //指向当前streamWriter.msgc字段

              heartbeatc <-chan time.Time  //定时器会定时向该通道发送信号,触发心跳消息的发送,该心跳消息与后台介绍的Raft的心跳消息有所不同,该心跳的主要目的是为了防止连接长时间不用断开的

              t          streamType    //用来记录消息的版本信息

              enc        encoder  //编码器,负责将消息序列化并写入连接的缓冲区

              flusher    http.Flusher  //负责刷新底层连接,将数据真正发送出去

              batched    int   //当前未Flush的消息个数

       )

       tickc := time.NewTicker(ConnReadTimeout / 3)  //发送心跳的定时器

       defer tickc.Stop()

       unflushed := 0   //为Flush的字节数



       if cw.lg != nil {

              cw.lg.Info(

                     "started stream writer with remote peer",

                     zap.String("local-member-id", cw.localID.String()),

                     zap.String("remote-peer-id", cw.peerID.String()),

              )

       } else {

              plog.Infof("started streaming with peer %s (writer)", cw.peerID)

       }



       for {

              select {

              case <-heartbeatc:   //定时器到期,触发心跳消息

                     err := enc.encode(&linkHeartbeatMessage)  //通过encoder将心跳编码并写入到writer

                     unflushed += linkHeartbeatMessage.Size()  //增加未Flush出去的字节数

                     if err == nil { //若没有异常,则使用flusher将缓存的消息全部发送出去,并重置batched和unflushed两个统计变量

                            flusher.Flush()

                            batched = 0

                            sentBytes.WithLabelValues(cw.peerID.String()).Add(float64(unflushed))

                            unflushed = 0

                            continue

                     }

                     //如果有异常则设置peer的status 为  不连通状态

                     cw.status.deactivate(failureType{source: t.String(), action: "heartbeat"}, err.Error())



                     sentFailures.WithLabelValues(cw.peerID.String()).Inc()

                     cw.close()  //若发生异常,则关闭streamWriter,会导致底层连接的关闭

                     if cw.lg != nil {

                            cw.lg.Warn(

                                   "lost TCP streaming connection with remote peer",

                                   zap.String("stream-writer-type", t.String()),

                                   zap.String("local-member-id", cw.localID.String()),

                                   zap.String("remote-peer-id", cw.peerID.String()),

                            )

                     } else {

                            plog.Warningf("lost the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)

                     }

                     //将heartbeatc和msgc两个通道清空,后续就不会在发送心跳消息和其他类型的消息了

                     heartbeatc, msgc = nil, nil



              case m := <-msgc:  //peer向streamWriter.msgc写入待发送的消息

                     err := enc.encode(&m)  //将消息序列化并写入底层连接

                     if err == nil {  //若没有异常,则递增unflushed变量

                            unflushed += m.Size()



                            //msgc通道中的消息全部发送完成或是未Flush的消息较多(超过streamBufSize的一半),则触发Flush,否则只是递增batched变量

                            if len(msgc) == 0 || batched > streamBufSize/2 {

                                   flusher.Flush()

                                   sentBytes.WithLabelValues(cw.peerID.String()).Add(float64(unflushed))

                                   unflushed = 0

                                   batched = 0

                            } else {

                                   batched++

                            }



                            continue

                     }



                     //若发生异常,则关闭streamWriter,清空heartbeatc和msgc两个通道



                     cw.status.deactivate(failureType{source: t.String(), action: "write"}, err.Error())

                     cw.close()

                     if cw.lg != nil {

                            cw.lg.Warn(

                                   "lost TCP streaming connection with remote peer",

                                   zap.String("stream-writer-type", t.String()),

                                   zap.String("local-member-id", cw.localID.String()),

                                   zap.String("remote-peer-id", cw.peerID.String()),

                            )

                     } else {

                            plog.Warningf("lost the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)

                     }

                     heartbeatc, msgc = nil, nil

                     cw.r.ReportUnreachable(m.To)

                     sentFailures.WithLabelValues(cw.peerID.String()).Inc()





              /*

                     当其他节点(对端)主动与当前节点创建Stream消息通道时,会先通过StreamHandler的处理,

                     StreamHandler会通过attach()方法将连接写入对应的peer.writer.connc通道,

                     而当前的goroutine会通过该通道获取连接,然后开始发送消息

              */

              case conn := <-cw.connc: //获取与当前streamWriter实例绑定的底层连接

                     cw.mu.Lock()

                     closed := cw.closeUnlocked()

                     t = conn.t    //获取该连接底层发送的消息版本,并创建相应的encoder实例

                     switch conn.t {    //不同的版本创建不同的编码器,将http.ResponseWriter封装成messageEncoder,上层调用通过messageEncoder实例完成消息发送

                     case streamTypeMsgAppV2:

                            enc = newMsgAppV2Encoder(conn.Writer, cw.fs)

                     case streamTypeMessage:

                            enc = &messageEncoder{w: conn.Writer}

                     default:

                            plog.Panicf("unhandled stream type %s", conn.t)

                     }

                     if cw.lg != nil {

                            cw.lg.Info(

                                   "set message encoder",

                                   zap.String("from", conn.localID.String()),

                                   zap.String("to", conn.peerID.String()),

                                   zap.String("stream-type", t.String()),

                            )

                     }

                     flusher = conn.Flusher   //记录底层连接对应的Flusher

                     unflushed = 0  //重置未Flush的字节数

                     cw.status.activate()  //peerStatus.active设置为true

                     cw.closer = conn.Closer  //负责关闭底层的长连接

                     cw.working = true //标识当前streamWriter正在运行

                     cw.mu.Unlock()



                     if closed {

                            if cw.lg != nil {

                                   cw.lg.Warn(

                                          "closed TCP streaming connection with remote peer",

                                          zap.String("stream-writer-type", t.String()),

                                          zap.String("local-member-id", cw.localID.String()),

                                          zap.String("remote-peer-id", cw.peerID.String()),

                                   )

                            } else {

                                   plog.Warningf("closed an existing TCP streaming connection with peer %s (%s writer)", cw.peerID, t)

                            }

                     }

                     if cw.lg != nil {

                            cw.lg.Warn(

                                   "established TCP streaming connection with remote peer",

                                   zap.String("stream-writer-type", t.String()),

                                   zap.String("local-member-id", cw.localID.String()),

                                   zap.String("remote-peer-id", cw.peerID.String()),

                            )

                     } else {

                            plog.Infof("established a TCP streaming connection with peer %s (%s writer)", cw.peerID, t)

                     }



                     //更新heartbeatc和msgc两个通道,自此之后,才能发送消息

                     heartbeatc, msgc = tickc.C, cw.msgc



              case <-cw.stopc:

                     if cw.close() {

                            if cw.lg != nil {

                                   cw.lg.Warn(

                                          "closed TCP streaming connection with remote peer",

                                          zap.String("stream-writer-type", t.String()),

                                          zap.String("remote-peer-id", cw.peerID.String()),

                                   )

                            } else {

                                   plog.Infof("closed the TCP streaming connection with peer %s (%s writer)", cw.peerID, t)

                            }

                     }

                     if cw.lg != nil {

                            cw.lg.Warn(

                                   "stopped TCP streaming connection with remote peer",

                                   zap.String("stream-writer-type", t.String()),

                                   zap.String("remote-peer-id", cw.peerID.String()),

                            )

                     } else {

                            plog.Infof("stopped streaming with peer %s (writer)", cw.peerID)

                     }

                     close(cw.done)

                     return

              }

       }

}

 

run方法的主要作用如下:

1.当其他节点主动与当前节点创建连接(即Stream消息通道底层使用的网络连接)时,该连接实例会写入对应的peer.writer.connc通道,

在streamWriter.run()方法中会通过该通道获取该连接实例并进行绑定,之后才能开始后续的消息发送

2.定时发送心跳,该心跳消息并不是前面介绍的etcd-raft模块时提到的MsgHeartbeat消息,而是为了防止底层连接超时的消息,为了维护长连接。

3.发送消息给对端,即msgc中等待发送给对端节点的消息。

 

 

3.attach方法

func (cw *streamWriter) attach(conn *outgoingConn) bool {

       select {

       case cw.connc <- conn:  //将conn实例写入streamWriter.connc通道中

              return true

       case <-cw.done:

              return false

       }

}

 

该方法主要用于接收对端的连接(该连接被封装成outgoingConn),并将outgoingConn实例并写入streamWriter.connc通道中。

 

 

二、streamReader实例

type streamReader struct {

       lg *zap.Logger



       peerID types.ID   //对端节点的ID

       typ    streamType    //关联的底层连接使用的协议版本信息



       tr     *Transport   //关联的rafthttp.Transport实例

       picker *urlPicker  //用于获取对端节点的可用的URL

       status *peerStatus  //

       recvc  chan<- raftpb.Message    //创建streamReader时会启动一个后台goroutine从peer.recvc通道中读取消息。从对端节点发送来的非MsgProp类型消息会写入到该通道中,然后由新建的goroutine读取出来,交给底层的etcd-raft模块进行处理

       propc  chan<- raftpb.Message   //功能基本同上,只不过用于接收MsgProp类型的消息。



       rl *rate.Limiter // alters the frequency of dial retrial attempts



       errorc chan<- error



       mu     sync.Mutex

       paused bool   //是否暂停

       closer io.Closer   //负责关闭底层的长连接



       ctx    context.Context

       cancel context.CancelFunc

       done   chan struct{}

}

 

主要功能是从Stream通道(底层连接)中读取消息

recvc 创建streamReader时会启动一个后台goroutine从peer.recvc通道中读取消息。从对端节点发送来的非MsgProp类型消息会写入到该通道中,然后由新建的goroutine读取出来,交给底层的etcd-raft模块进行处理。

propc 功能基本同上,只不过用于接收MsgProp类型的消息。

 

streamReader的初始化

 func (cr *streamReader) start() {

       cr.done = make(chan struct{})

       if cr.errorc == nil {

              cr.errorc = cr.tr.ErrorC

       }

       if cr.ctx == nil {

              cr.ctx, cr.cancel = context.WithCancel(context.Background())

       }

       go cr.run()

}

 

初始化 done、errorc及ctx、cancel等相关字段,然后开启一个协程执行run方法

func (cr *streamReader) run() {

       t := cr.typ   //获取使用的消息版本



       //省略日志相关



       for {

              rc, err := cr.dial(t)  //向对端节点发送一个GET请求,然后获取并返回响应的ReadCloser,主要用于和对端建立连接

              if err != nil {

                     if err != errUnsupportedStreamType {

                            cr.status.deactivate(failureType{source: t.String(), action: "dial"}, err.Error())

                     }

              } else {//如果未出现异常,则开始读取对端返回的消息,并将读取到的消息写入streamReader.recvc通道中

                     cr.status.activate()

                    

                     err = cr.decodeLoop(rc, t)  //轮询读取消息

                     //省略日志相关......                    



                     switch {

                     // all data is read out

                     case err == io.EOF:

                     // connection is closed by the remote

                     case transport.IsClosedConnError(err):

                     default:

                            cr.status.deactivate(failureType{source: t.String(), action: "read"}, err.Error())

                     }

              }

              // Wait for a while before new dial attempt

              err = cr.rl.Wait(cr.ctx)

              if cr.ctx.Err() != nil {

                     if cr.lg != nil {

                            cr.lg.Info(

                                   "stopped stream reader with remote peer",

                                   zap.String("stream-reader-type", t.String()),

                                   zap.String("local-member-id", cr.tr.ID.String()),

                                   zap.String("remote-peer-id", cr.peerID.String()),

                            )

                     } else {

                            plog.Infof("stopped streaming with peer %s (%s reader)", cr.peerID, t)

                     }

                     close(cr.done)

                     return

              }

              if err != nil {

                     if cr.lg != nil {

                            cr.lg.Warn(

                                   "rate limit on stream reader with remote peer",

                                   zap.String("stream-reader-type", t.String()),

                                   zap.String("local-member-id", cr.tr.ID.String()),

                                   zap.String("remote-peer-id", cr.peerID.String()),

                                   zap.Error(err),

                            )

                     } else {

                            plog.Errorf("streaming with peer %s (%s reader) rate limiter error: %v", cr.peerID, t, err)

                     }

              }

       }

}

 

run方法时streamReader的核心,首先调用dial方法给对端发送一个GET请求,从而和对端建立长连接。对端的Header收到该连接后,会封装成outgoingConn结构,并发送给streamWriter,即上面介绍的,当streamWriter收到新建的连接后,会用心跳维持该连接。

 

连接建立成功之后会调用decodeLoop方法来轮询读取对端节点发送过来的消息,并将收到的字节流转成raftpb.Message消息类型的格式。如果消息是心跳类型则忽略,如果是raftpb.MsgProp类型的消息,则发送到propc通道中,会有专门的协程发送给本节点底层的raft模块。如果是其他消息(注意这些消息里没有快照类型的消息,因为快照类型的消息是专门的通道),则发送到recvc通道中,会有专门的协程将数据发送给底层的raft模块。

 

dial方法

func (cr *streamReader) dial(t streamType) (io.ReadCloser, error) {

       u := cr.picker.pick()   //获取对端节点暴露的一个URL

       uu := u

       //根据使用的协议版本号和节点ID创建最终的URL地址

       uu.Path = path.Join(t.endpoint(), cr.tr.ID.String())



      

       //创建一个GET请求

       req, err := http.NewRequest("GET", uu.String(), nil)

       if err != nil {

              cr.picker.unreachable(u)

              return nil, fmt.Errorf("failed to make http request to %v (%v)", u, err)

       }

       //设置HTTP请求头

       req.Header.Set("X-Server-From", cr.tr.ID.String())

       req.Header.Set("X-Server-Version", version.Version)

       req.Header.Set("X-Min-Cluster-Version", version.MinClusterVersion)

       req.Header.Set("X-Etcd-Cluster-ID", cr.tr.ClusterID.String())

       req.Header.Set("X-Raft-To", cr.peerID.String())



       //通过设置Header,将当前节点暴露的URL也一起发送给对端节点

       setPeerURLsHeader(req, cr.tr.URLs)



       req = req.WithContext(cr.ctx)



       cr.mu.Lock()

       select {

       case <-cr.ctx.Done():

              cr.mu.Unlock()

              return nil, fmt.Errorf("stream reader is stopped")

       default:

       }

       cr.mu.Unlock()



       //发送请求  ping-pone

       resp, err := cr.tr.streamRt.RoundTrip(req)

       if err != nil {

              cr.picker.unreachable(u)

              return nil, err

       }



       rv := serverVersion(resp.Header)

       lv := semver.Must(semver.NewVersion(version.Version))

       if compareMajorMinorVersion(rv, lv) == -1 && !checkStreamSupport(rv, t) {

              httputil.GracefulClose(resp)

              cr.picker.unreachable(u)

              return nil, errUnsupportedStreamType

       }



       switch resp.StatusCode {



       case http.StatusOK:

              return resp.Body, nil

     //省略其他错误处理

       }

}

 

主要负责与对端节点建立连接,其中包含了多种异常情况的处理。

看到创建GET请求,并设置HTTP请求头信息,调用RoundTrip发送请求到对端。

当返回成功时,将resp.Body返回。

 

decodeLoop方法

func (cr *streamReader) decodeLoop(rc io.ReadCloser, t streamType) error {

       var dec decoder

       cr.mu.Lock()

       //根据使用的协议版本创建对应的decoder实例

       switch t {

       case streamTypeMsgAppV2:

              dec = newMsgAppV2Decoder(rc, cr.tr.ID, cr.peerID)

       case streamTypeMessage:

              dec = &messageDecoder{r: rc}   //主要负责从连接中读取消息

       default:

              if cr.lg != nil {

                     cr.lg.Panic("unknown stream type", zap.String("type", t.String()))

              } else {

                     plog.Panicf("unhandled stream type %s", t)

              }

       }



       //检测是否已经暂停从该连接上读取消息

       select {

       case <-cr.ctx.Done():

              cr.mu.Unlock()

              if err := rc.Close(); err != nil {

                     return err

              }

              return io.EOF

       default:

              cr.closer = rc

       }

       cr.mu.Unlock()



       // gofail: labelRaftDropHeartbeat:

       for {

              //从底层连接中读取数据,并反序列化成raftpb.Message实例

              m, err := dec.decode()

              if err != nil {

                     cr.mu.Lock()

                     cr.close()

                     cr.mu.Unlock()

                     return err

              }



              // gofail-go: var raftDropHeartbeat struct{}

              // continue labelRaftDropHeartbeat

              receivedBytes.WithLabelValues(types.ID(m.From).String()).Add(float64(m.Size()))



              cr.mu.Lock()

              paused := cr.paused

              cr.mu.Unlock()



              if paused {

                     continue

              }



              // 忽略连接层的心跳消息,注意与后面介绍的Raft的心跳消息进行区分

              if isLinkHeartbeatMessage(&m) {

                     // raft is not interested in link layer

                     // heartbeat message, so we should ignore

                     // it.

                     continue

              }



              //根据消息类型获取要写入的通道

              recvc := cr.recvc

              if m.Type == raftpb.MsgProp {

                     recvc = cr.propc

              }



              select {

              case recvc <- m:  //将消息写入到对应的通道中,之后交给底层的Raft状态机进行处理

              default:

              //省略异常处理

              }

       }

}

 

该方法的主要作用就是 从底层的网络连接读取数据并进行反序列化,之前将得到的消息写入到recvc通道或propc通道中,等待Peer进行处理。

遥感图像地物覆盖分类,数据集制作-分类模型对比-分类保姆级教程 1.新建shp文件地理坐标系保持和影像一致,面类型2.打开属性表3.添加字段这里分类6类,点击添加值添加添加完毕开始人工选地物类型,制作数据集开始标注,标注的时候可以借助谷歌地图来看标记足够多的样本打开面转栅格工具设置nodata值为15。 阅读详情

相关推荐

Spring Authorization Server自定义密码模式:突破标准OAuth2限制,实现MFA与复杂业务集成

OAuth 2.0授权框架是构建现代应用安全体系的基石,其密码模式(Resource Owner Password Credentials Grant)提供了一种直接的资源所有者凭证交换令牌的机制。该模式的核心原理是客户端收集用户密码并直接向授权服务器请求访问令牌,适用于受信任的客户端场景。在技术价值上,它简化了某些传统应用的OAuth集成流程。然而,标准实现往往难以满足复杂的现实业务需求,例如需要集成多因素认证(MFA)、对接外部LDAP目录服务或执行自定义密码加密校验等场景。Spring Authori

weixin_34302561的博客 438

etcd系列-----raft网络层实现之rafthttp模块

待续

cyq6239075的博客 2204

中兴畅行60 ZTE 7552N 深度改造指南:从解锁BL到Magisk Root与IMEI硬改全流程

本文详细介绍了中兴畅行60(ZTE 7552N)的深度改造全流程,包括解锁BL、刷入Magisk获取Root权限以及IMEI硬改等关键步骤。通过专业的操作指南和实用技巧,帮助用户安全完成设备改造,同时提醒注意法律风险和技术难点。

weixin_33670786的博客 1935

etcd网络层源码分析(四)——stream通道实现

etcd网络层(四)——stream接口实现

高思维深思考的博客 2344

Windows 11任务管理器隐藏技能:一眼揪出内存泄漏的“元凶”(分页/非分页缓冲池详解)

本文详细介绍了Windows 11任务管理器中隐藏的分页缓冲池和非分页缓冲池功能,帮助用户精准定位内存泄漏问题。通过启用隐藏列、解读数据异常信号,并结合实战案例和高级工具推荐,为开发者和IT运维人员提供了高效的内存问题诊断与解决方案。

weixin_29284885的博客 635

Palantir解密:“本体”的建模逻辑及其扩展方向

上一篇重点从对现实世界建模的角度探讨了“本体”在数字化架构中的核心意义。这里借Palantir的“本体”概念、解析Palantir只是起点,目标旨在以他山之石攻玉——探索数字世界的底层架构逻辑,最终为构建自主体系提供思考。Palantir以“本体论”为核心的建模方案是否代表终极答案,不宜过早下结论,但其思路值得深入剖析。

SZSDQJC的博客 2637

Etcd源码分析-网络模型进阶篇

起初本篇打算介绍raft相关,但是后来发现,还是有必要再深入介绍一下网络模型。一、基础网络模型 Etcd采用http(https)协议作为应用层协议,关于http协议介绍不是本篇范畴。大家都知道http一般情况下是无状态协议,且网络是为请求+应答模式,当收到应答http session就结束了(tcp可能不结束)。但是在etcd中可能就不是这样子了。下面是抓取的http报文: ...

程序员的世界 3502

primetime如何做voltage scaling

存在这样的情况,标准单元库只有ssgnp0p72vm40c和ssgnp0p9vm40c的libs,但是我们希望它工作在ssgnp0p76vm40c,这样的话就需要用ssgnp0p72vm40c和ssgnp0p9vm40c的libs来scaling出ssgnp0p76vm40c的lib。

qq_34326957的博客 1686

【k8s】- 记一则k3s服务重启失败

containerd 试图在其主要端点上启动服务时遇到了问题,具体错误是“device or resource busy”(设备或资源正忙)。这通常意味着该套接字文件已经被另一个进程占用,或者由于某种原因,containerd 无法访问该文件。需要找到占用套接字文件的进程再分析。

m0_55928215的博客 1987

Dobot Magician机械臂二次开发指南:如何利用Python脚本和I/O接口实现自动化任务

本文详细介绍了Dobot Magician机械臂的二次开发方法,重点讲解如何通过Python脚本和I/O接口实现高级自动化任务。内容包括开发环境搭建、运动控制API解析、I/O接口应用以及典型场景实现,帮助开发者充分发挥Dobot Magician的潜力,适用于工业自动化、教育科研等领域。

weixin_26968079的博客 268

高通MBIM拨号流程简述

高通平台MBIM流程简述

不秃头的程序猿Gabriel的博客 5071

基于etcdserver包将自己的go程序打造成高可用系统(上)

我们每一个系统开发人员都希望自己的程序永远不宕机,高可用是很多系统的目标。那我们如何把自己的系统改造成高可用的系统呢?带着这个问题,本文就给大家演示下,如何自己动手,从零开始基于raft协议来改造我们的已有系统。很多同学都知道Raft协议是一种分布式一致性算法。从用户的角度出发,它提供给程序设计人员的功能主要有以下2个方面当然很多同学讲到,我们可以直接部署高可用的分布式键值存储系统etcd,它本身具有高可用、高并发、一致性等特点,已经被广泛应用于云计算、微服务、容器等领域了,是很多云原生系统的底层基石之一。

dongluyang2007的博客 395

MIC:最大信息系数

目录 1. 概念 1.1 MIC 1.2 互信息 2.MIC的优点 3. 算法原理 3.1 MIC公式原理 3.2MIC计算步骤 (1)计算最大互信息值 (2)对最大的互信息值进行归一化 (3)选择不同尺度下互信息的最大值作为MIC值 4. 代码实现 6. 其他方法 1. 概念 1.1 MIC MIC,即(Maximal Information...

满腹的小不甘 5万+

ETCD系列之三:网络层实现

ETCD系列之三:网络层实现 1. 概述 在理清ETCD的各个模块的实现细节后,方便线上运维,理解各种参数组合的意义。本文先从网络层入手,后续文章会依次介绍各个模块的实现。 本文将着重介绍ETCD服务的网络层实现细节。在目前的实现中,ETCD通过HTTP协议对外提供服务,同样通过HTTP协议实现集群节点间数据交互。 网络层的主要功能是实现了服务器与客户端(能发出HTTP请求的各种程序)消息交互,以及集群内部各节点之间的消息交互。 2. ETCD-SERVER整体架构 ETCD-SERVER 大体

技术心得总结 748

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

etcd 部署集群 etcd 网络层实现 etcd 是什么

想必很多人都知道 ZooKeeper, 通常用作配置共享和服务发现。和它类似, etcd 算是一个非常优秀的后起之秀了。本文重点不在描述他们之间的不同点。在云计算大行其道的今天, etcd 有很多典型的使用场景。常言道, 熟悉一个系统先从部署开始。本文接下来将描述, 如何部署 etcd 集群。通过静态配置方式启动通过服务发现方式启动在部署集群之前, 我们需要考虑集群需要配置多少个节点。这是一个重要的考量, 不得忽略。在理清 etcd 的各个模块的实现细节后, 方便线上运维, 理解各种参数组合的意义。

云满笔记 1262

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

etcd网络层(四)——Peer接口的实现

peer结构体是Peer接口的实现,peer是远程raft节点的代表,本地raft节点通过peer给远程raft节点发送消息 每个peer有两个发送消息的基本机制:stream和pipeline stream是长连接,它始终可以传输消息。除了通常的stream,还有优化的stream用于leader发送msgApp消息,因为msgApp占了大部分的消息 pipeline是一系列客户端发送请求...

skh2015java的博客 1554

etcd网络层源码分析(一)

etcdserver.NewServer //轻量级,用了不会关闭 var err error t.streamRt, err = newStreamRoundTripper(t.TLSInfo, t.DialTimeout) if err != nil { return err } //对于大的数据pipeline,用了立刻关闭的入口 t.pipelineRt, err = NewRoundTripper(t.TLSInfo, t.DialTimeout) if err != nil { retur

高思维深思考的博客 504

ETCD数据库源码分析——集群间网络层服务端RaftHandler

在ETCD数据库源码分析——集群间网络层服务端接口文章中,启动http.Server时会通过rafthttp.Transporter.Handler()方法为指定的URL路径添加相应Handler实例,如下图所示。streamHandler负责处理Stream消息通道上的请求。pipelineHandler负责处理Pipeline通道上的请求,snapHandler负责处理Pipeline通道上的请求。 pipelineHandler用于集群间网络层服务端负责处理Pipeline通道上的请求,tr为当前pi

肥叔菌的博客 945

ETCD介绍—etcd概念及原理方面分析

etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。 简单:基于HTTP+JSON的API让你用curl就可以轻松使用。 安全:可选SSL客户认证机制。 快速:每个实例每秒支持一千次写操作。 可信:使用Raft算法充分实现了分布式。 分布式系统中的数据分为控制数据和应用数据。etcd的使用场景默认处理的数据都是控制数据,对于应用数据,只推荐数据量很小,但是更新访问频繁的情况。应用场景有如下几类:场景一:服务发现(Service Discovery

chang_ge的博客 1115

ETCD是什么

1. ETCD是什么 ETCD是用于共享配置和服务发现的分布式,一致性的KV存储系统。该项目目前最新稳定版本为2.3.0. 具体信息请参考[项目首页]和[Github]。ETCD是CoreOS公司发起的一个开源项目,授权协议为Apache。 提供配置共享和服务发现的系统比较多,其中最为大家熟知的是[Zookeeper](后文简称ZK),而ETCD可以算得上是后起之秀了。在项目实现,一致性协议易理解性,运维,安全等多个维度上,ETCD相比Zookeeper都占据优势。 2. ETCD vs ZK

weixin_57763462的博客 481

etcd 启动分析_ETCD相关介绍--整体概念及原理方面

etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。简单:基于HTTP+JSON的API让你用curl就可以轻松使用。安全:可选SSL客户认证机制。快速:每个实例每秒支持一千次写操作。可信:使用Raft算法充分实现了分布式。分布式系统中的数据分为控制数据和应用数据。etcd的使用场景默认处理的数据都是控制数据,对于应用数据,只推荐数据量...

weixin_39925413的博客 564

etcd网络层(六)——模拟etcd网络层的stream通道维护长连接

代码如下: package main import ( "io" "log" "net" "fmt" "sync" "time" "strings" "strconv" "net/http" "encoding/json" "encoding/binary" ) func main() { peerURL1 := "http://127.0.0.1:8081" p...

skh2015java的博客 1085

etcd网络层源码分析(二)——Transporter接口实现

1.dial网络频率限制

高思维深思考的博客 616

etcd网络通讯层(一)——rafthttp中重要的接口

前面我们提到etcd-raft模块,etcd-raft模块并未提供网络层的相关实现,而是将待发送的消息封装进Ready实例返回给上层模块,然后由上层模块决定如何将这些消息发送到集群中的其他节点。etcd将网络层的相关实现单独封装成一个模块,也就是etcd-rafthttp模块。从而降低了etcd-raft和etcd-rafthttp之间的耦合,提高程序的可扩展性。 et...

skh2015java的博客 1842

ETCD结构、特点及和zookeeper对比

文章目录etcd 是什么etcd结构简介etcd 数据通道etcd通信架构应用场景和ZK对比 etcd 是什么 etcd 这个名字由两部分组成: etc 和 d ,即 UNIX/Linux操作系统的“/etc” 目录和分布式( distributed )首字母的“d ” 。我们都知道,/etc目录一般用于存 储 UNIX/Linux 操作系统的配置信息 因此etc和d合起来就是一个分布式的/etc 目录。etcd 的寓意是为大规模分布式系统存储配置信息。 etcd 的官方定义如下: A highly-ava

zhangxm_qz的博客 3881

深入浅出之etcd

分布式系统的难点在于“部分失败”。部分失败指信息在网络的两个节点之间传送出现了故障,发送者不知道接收者是否收到了这个信息,并且导致这种故障的原因很多,接收者也可能在发生网络错误之前收到了信息,也可能没收到。 现在的键值数据库基本都是分布式的,Zookeeper是其中久负盛名的一个,它有很成熟,丰富的特性,但它有自己的缺点,具体如下: 复杂:ZooKeeper部署维护比较复杂,管理员必须掌握一系列知识,Zookeeper使用的Pzxos强一致性算法不易于理解 Zookeeper仅提供Java和C两种接口,另

不务正业随手记 1151

ETCD相关介绍--整体概念及原理方面

转载 https://www.cnblogs.com/softidea/p/6517959.html etcd作为一个受到ZooKeeper与doozer启发而催生的项目,除了拥有与之类似的功能外,更专注于以下四点。 简单:基于HTTP+JSON的API让你用curl就可以轻松使用。 安全:可选SSL客户认证机制。 快速:每个实例每秒支持一千次写操作。 可信:使用Raft算法充分实...

weixin_34097242的博客 133
上一篇: etcd网络层(二)——pipeline通道实现
下一篇: Golang并发模型的示例
思维的深度
博客等级 码龄11年 2万+粉丝 391原创
评论 5
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值