Fabric 1.4 原始碼分析 區塊同步

本文主要從原始碼層面介紹fabric peer同步區塊過程，peer同步區塊主要有2個過程：
1）peer組織的leader與orderer同步區塊
2）peer組織間peer同步區塊。

1. peer leader和orderer同步區塊

首先，orderer對外主要是broadcast和deliver兩個服務orderer服務介紹。並且我們知道peer和orderer同步區塊肯定是deliver服務實現的，但是到底是peer從orderer拉還是ordrer推送給peer呢？由於peer可以知道orderer資訊（配置塊）並且是grpc服務，則推斷是peer從orderer拉區塊。如果是拉區塊，那麼peer如何獲取區塊，獲取區塊的方式是什麼？

1.1 Orderer Deliver服務

首先，檢視orderer deliver服務是怎麼執行的，是如何同步區塊的。
當deliver服務被呼叫時，轉到Handle()方法處理

func (h *Handler) Handle(ctx context.Context, srv *Server) error {
    ...
    for {
        logger.Debugf("Attempting to read seek info message from %s", addr)
        // 接受發來envelope
        envelope, err := srv.Recv()
        ...
        // 分發區塊
        status, err := h.deliverBlocks(ctx, srv, envelope)
        ...
    }
}
 

其中，srv.Recv()接收envelope，在根據envelope資訊分發block。

func (h *Handler) deliverBlocks(ctx context.Context, srv *Server, envelope *cb.Envelope) (status cb.Status, err error) {
    addr := util.ExtractRemoteAddress(ctx)
    payload, err := utils.UnmarshalPayload(envelope.Payload)
    if payload.Header == nil {
        logger.Warningf("Malformed envelope received from %s with bad header", addr)
        return cb.Status_BAD_REQUEST, nil
    }
    chdr, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)
    err = h.validateChannelHeader(ctx, chdr)
    chain := h.ChainManager.GetChain(chdr.ChannelId)
    defer func() {
        labels := append(labels, "success", strconv.FormatBool(status == cb.Status_SUCCESS))
        h.Metrics.RequestsCompleted.With(labels...).Add(1)
    }()

    accessControl, err := NewSessionAC(chain, envelope, srv.PolicyChecker, chdr.ChannelId, crypto.ExpiresAt)
    if err != nil {
        logger.Warningf("[channel: %s] failed to create access control object due to %s", chdr.ChannelId, err)
        return cb.Status_BAD_REQUEST, nil
    }

    if err := accessControl.Evaluate(); err != nil {
        logger.Warningf("[channel: %s] Client authorization revoked for deliver request from %s: %s", chdr.ChannelId, addr, err)
        return cb.Status_FORBIDDEN, nil
    }

    seekInfo := &ab.SeekInfo{}
    // 返回迭代器及起始區塊號
    cursor, number := chain.Reader().Iterator(seekInfo.Start)
    defer cursor.Close()
    var stopNum uint64
    switch stop := seekInfo.Stop.Type.(type) {
    case *ab.SeekPosition_Oldest:
        stopNum = number
    case *ab.SeekPosition_Newest:
        stopNum = chain.Reader().Height() - 1
    case *ab.SeekPosition_Specified:
        stopNum = stop.Specified.Number
        if stopNum < number {
            logger.Warningf("[channel: %s] Received invalid seekInfo message from %s: start number %d greater than stop number %d", chdr.ChannelId, addr, number, stopNum)
            return cb.Status_BAD_REQUEST, nil
        }
    }

    for {
        if seekInfo.Behavior == ab.SeekInfo_FAIL_IF_NOT_READY {
            if number > chain.Reader().Height()-1 {
                return cb.Status_NOT_FOUND, nil
            }
        }

        var block *cb.Block
        var status cb.Status

        iterCh := make(chan struct{})
        go func() {
            // 獲取區塊
            block, status = cursor.Next()
            close(iterCh)
        }()

        select {
        case <-ctx.Done():
            logger.Debugf("Context canceled, aborting wait for next block")
            return cb.Status_INTERNAL_SERVER_ERROR, errors.Wrapf(ctx.Err(), "context finished before block retrieved")
        case <-erroredChan:
            // TODO, today, the only user of the errorChan is the orderer consensus implementations.  If the peer ever reports
            // this error, we will need to update this error message, possibly finding a way to signal what error text to return.
            logger.Warningf("Aborting deliver for request because the backing consensus implementation indicates an error")
            return cb.Status_SERVICE_UNAVAILABLE, nil
        case <-iterCh:
            // Iterator has set the block and status vars
        }

        if status != cb.Status_SUCCESS {
            logger.Errorf("[channel: %s] Error reading from channel, cause was: %v", chdr.ChannelId, status)
            return status, nil
        }

        // increment block number to support FAIL_IF_NOT_READY deliver behavior
        number++

        if err := accessControl.Evaluate(); err != nil {
            logger.Warningf("[channel: %s] Client authorization revoked for deliver request from %s: %s", chdr.ChannelId, addr, err)
            return cb.Status_FORBIDDEN, nil
        }

        logger.Debugf("[channel: %s] Delivering block for (%p) for %s", chdr.ChannelId, seekInfo, addr)
        // 傳送區塊
        if err := srv.SendBlockResponse(block); err != nil {
            logger.Warningf("[channel: %s] Error sending to %s: %s", chdr.ChannelId, addr, err)
            return cb.Status_INTERNAL_SERVER_ERROR, err
        }

        h.Metrics.BlocksSent.With(labels...).Add(1)
        // 如果到了client請求對最後區塊跳出迴圈
        if stopNum == block.Header.Number {
            break
        }
    }

    logger.Debugf("[channel: %s] Done delivering to %s for (%p)", chdr.ChannelId, addr, seekInfo)

    return cb.Status_SUCCESS, nil
}
 

1. 反序列化envelope.Payload
2. 對payload.Header和ChannelHeader進行驗證
3. 根據通道獲取對應對chain
4. 訪問控制相關驗證，policy，signature
5. 從payload.data解析出SeekInfo
6. 新建一個迭代器cursor
7. 通過stop.type判斷stopNum()
8. cursor.Next()獲取下個區塊及SendBlockResponse()傳送區塊
9. 判斷是否達到請求的最後區塊，是就跳過迴圈

// Chain encapsulates chain operations and data.
type Chain interface {
    // Sequence returns the current config sequence number, can be used to detect config changes
    Sequence() uint64

    // PolicyManager returns the current policy manager as specified by the chain configuration
    PolicyManager() policies.Manager

    // Reader returns the chain Reader for the chain
    Reader() blockledger.Reader

    // Errored returns a channel which closes when the backing consenter has errored
    Errored() <-chan struct{}
}

type SeekInfo struct {
    Start                *SeekPosition         `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
    Stop                 *SeekPosition         `protobuf:"bytes,2,opt,name=stop,proto3" json:"stop,omitempty"`
    Behavior             SeekInfo_SeekBehavior `protobuf:"varint,3,opt,name=behavior,proto3,enum=orderer.SeekInfo_SeekBehavior" json:"behavior,omitempty"`
    XXX_NoUnkeyedLiteral struct{}              `json:"-"`
    XXX_unrecognized     []byte                `json:"-"`
    XXX_sizecache        int32                 `json:"-"`
}

1.2 peer從orderer同步區塊

這裡主要解決1個問題：peer如何觸發orderer deliver服務？即peer和orderer怎麼同步區塊的？
在介紹之前參閱peer節點啟動流程。在peer節點啟動過程中會執行peer.Initialize()方法，對peer所在的所有chain例項化。其中呼叫了createChain()介面建立鏈物件。在createChain()方法中呼叫了GossipService.InitializeChannel()方法。然後呼叫g.deliveryService[chainID].StartDeliverForChannel()方法獲取區塊。

func (d *deliverServiceImpl) StartDeliverForChannel(chainID string, ledgerInfo blocksprovider.LedgerInfo, finalizer func()) error {
    d.lock.Lock()
    defer d.lock.Unlock()
    if d.stopping {
        errMsg := fmt.Sprintf("Delivery service is stopping cannot join a new channel %s", chainID)
        logger.Errorf(errMsg)
        return errors.New(errMsg)
    }
    if _, exist := d.blockProviders[chainID]; exist {
        errMsg := fmt.Sprintf("Delivery service - block provider already exists for %s found, can't start delivery", chainID)
        logger.Errorf(errMsg)
        return errors.New(errMsg)
    } else {
        client := d.newClient(chainID, ledgerInfo)
        logger.Debug("This peer will pass blocks from orderer service to other peers for channel", chainID)
        // 建立區塊deliver例項
        d.blockProviders[chainID] = blocksprovider.NewBlocksProvider(chainID, client, d.conf.Gossip, d.conf.CryptoSvc)
        // 執行
        go d.launchBlockProvider(chainID, finalizer)
    }
    return nil
}

其中newClient()建立一個broadcastClient，傳入引數為requester.RequestBlocks(ledgerInfoProvider)方法。很顯然，peer是通過該方法獲取區塊的，那麼該方法主要實現是什麼？

func (b *blocksRequester) RequestBlocks(ledgerInfoProvider blocksprovider.LedgerInfo) error {
    height, err := ledgerInfoProvider.LedgerHeight()
    if err != nil {
        logger.Errorf("Can't get ledger height for channel %s from committer [%s]", b.chainID, err)
        return err
    }

    if height > 0 {
        logger.Debugf("Starting deliver with block [%d] for channel %s", height, b.chainID)
        if err := b.seekLatestFromCommitter(height); err != nil {
            return err
        }
    } else {
        logger.Debugf("Starting deliver with oldest block for channel %s", b.chainID)
        if err := b.seekOldest(); err != nil {
            return err
        }
    }

    return nil
}

呼叫了seek_XXX方法，其中

type SeekInfo struct {
    Start                *SeekPosition         `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
    Stop                 *SeekPosition         `protobuf:"bytes,2,opt,name=stop,proto3" json:"stop,omitempty"`
    Behavior             SeekInfo_SeekBehavior `protobuf:"varint,3,opt,name=behavior,proto3,enum=orderer.SeekInfo_SeekBehavior" json:"behavior,omitempty"`
    XXX_NoUnkeyedLiteral struct{}              `json:"-"`
    XXX_unrecognized     []byte                `json:"-"`
    XXX_sizecache        int32                 `json:"-"`
}

func (b *blocksRequester) seekOldest() error {
    seekInfo := &orderer.SeekInfo{
        Start:    &orderer.SeekPosition{Type: &orderer.SeekPosition_Oldest{Oldest: &orderer.SeekOldest{}}},
        Stop:     &orderer.SeekPosition{Type: &orderer.SeekPosition_Specified{Specified: &orderer.SeekSpecified{Number: math.MaxUint64}}},
        Behavior: orderer.SeekInfo_BLOCK_UNTIL_READY,
    }

    //TODO- epoch and msgVersion may need to be obtained for nowfollowing usage in orderer/configupdate/configupdate.go
    msgVersion := int32(0)
    epoch := uint64(0)
    tlsCertHash := b.getTLSCertHash()
    env, err := utils.CreateSignedEnvelopeWithTLSBinding(common.HeaderType_DELIVER_SEEK_INFO, b.chainID, localmsp.NewSigner(), seekInfo, msgVersion, epoch, tlsCertHash)
    if err != nil {
        return err
    }
    // 傳送envelope給orderer獲取區塊
    return b.client.Send(env)
}

從其中RequestBlocks()呼叫的2個方法可知,seekInfo的stopNum都為math.MaxUint64，則該方法會持續請求區塊知道最大值（可以看作現在到未來的所有區塊）。

上文可知，broadcastClient已經例項化，並且通過呼叫broadcastClient.onConnect向orderer傳送獲取區塊的envelope。在例項化後，呼叫launchBlockProvider。然後會呼叫 pb.DeliverBlocks()方法（開始獲取區塊）。

type broadcastClient struct {
    stopFlag     int32
    stopChan     chan struct{}
    createClient clientFactory
    shouldRetry  retryPolicy
    onConnect    broadcastSetup
    prod         comm.ConnectionProducer

    mutex           sync.Mutex
    blocksDeliverer blocksprovider.BlocksDeliverer
    conn            *connection
    endpoint        string
}

// DeliverBlocks used to pull out blocks from the ordering service to
// distributed them across peers
func (b *blocksProviderImpl) DeliverBlocks() {
    errorStatusCounter := 0
    statusCounter := 0
    defer b.client.Close()
    for !b.isDone() {
        // 接收orderer分發的區塊
        msg, err := b.client.Recv()
        if err != nil {
            logger.Warningf("[%s] Receive error: %s", b.chainID, err.Error())
            return
        }
        switch t := msg.Type.(type) {
        case *orderer.DeliverResponse_Status:
            if t.Status == common.Status_SUCCESS {
                logger.Warningf("[%s] ERROR! Received success for a seek that should never complete", b.chainID)
                return
            }
            if t.Status == common.Status_BAD_REQUEST || t.Status == common.Status_FORBIDDEN {
                logger.Errorf("[%s] Got error %v", b.chainID, t)
                errorStatusCounter++
                if errorStatusCounter > b.wrongStatusThreshold {
                    logger.Criticalf("[%s] Wrong statuses threshold passed, stopping block provider", b.chainID)
                    return
                }
            } else {
                errorStatusCounter = 0
                logger.Warningf("[%s] Got error %v", b.chainID, t)
            }
            maxDelay := float64(maxRetryDelay)
            currDelay := float64(time.Duration(math.Pow(2, float64(statusCounter))) * 100 * time.Millisecond)
            time.Sleep(time.Duration(math.Min(maxDelay, currDelay)))
            if currDelay < maxDelay {
                statusCounter++
            }
            if t.Status == common.Status_BAD_REQUEST {
                b.client.Disconnect(false)
            } else {
                b.client.Disconnect(true)
            }
            continue
        case *orderer.DeliverResponse_Block:
            errorStatusCounter = 0
            statusCounter = 0
            blockNum := t.Block.Header.Number

            marshaledBlock, err := proto.Marshal(t.Block)
            if err != nil {
                logger.Errorf("[%s] Error serializing block with sequence number %d, due to %s", b.chainID, blockNum, err)
                continue
            }
            if err := b.mcs.VerifyBlock(gossipcommon.ChainID(b.chainID), blockNum, marshaledBlock); err != nil {
                logger.Errorf("[%s] Error verifying block with sequnce number %d, due to %s", b.chainID, blockNum, err)
                continue
            }

            numberOfPeers := len(b.gossip.PeersOfChannel(gossipcommon.ChainID(b.chainID)))
            // Create payload with a block received
            payload := createPayload(blockNum, marshaledBlock)
            // Use payload to create gossip message
            gossipMsg := createGossipMsg(b.chainID, payload)

            logger.Debugf("[%s] Adding payload to local buffer, blockNum = [%d]", b.chainID, blockNum)
            // Add payload to local state payloads buffer
            if err := b.gossip.AddPayload(b.chainID, payload); err != nil {
                logger.Warningf("Block [%d] received from ordering service wasn't added to payload buffer: %v", blockNum, err)
            }

            // Gossip messages with other nodes
            logger.Debugf("[%s] Gossiping block [%d], peers number [%d]", b.chainID, blockNum, numberOfPeers)
        
            if !b.isDone() {
                // peer節點間通過gossip同步區塊
                b.gossip.Gossip(gossipMsg)
            }
        default:
            logger.Warningf("[%s] Received unknown: %v", b.chainID, t)
            return
        }
    }
}

DeliverBlocks()方法介紹，首先呼叫 b.client.Recv()接收orderer傳過來的響應，

// Recv receives a message from the ordering service
func (bc *broadcastClient) Recv() (*orderer.DeliverResponse, error) {
    o, err := bc.try(func() (interface{}, error) {
        if bc.shouldStop() {
            return nil, errors.New("closing")
        }
        return bc.tryReceive()
    })
    if err != nil {
        return nil, err
    }
    return o.(*orderer.DeliverResponse), nil
}

這裡我們知道大致是peer從orderer這裡拉區塊的，但是還存在疑問，那就是peer如何觸發orderer的deliver服務的？peer是如何呼叫requestBlock方法的？

• peer 呼叫deliver服務
  從Recv()介面會呼叫try(),try()會呼叫bc.doAction(action, resetAttemptCounter)，然後呼叫bc.connect()，裡面呼叫bc.createClient(conn).Deliver(ctx)，從而peer呼叫了orderer的deliver服務。
• peer 呼叫requestBlock方法
  從上面可知，requestBlock賦值給broadcastSetup，而broadcastSetup在連線orderer後會立即呼叫。

// broadcastSetup is a function that is called by the broadcastClient immediately after each
// successful connection to the ordering service

1.3 組織間peer同步區塊

peer間同步區塊是通過gossip服務來同步的，並且通過上述程式碼可知，leader和orderer同步區塊也是伴隨著gossip服務啟動（不過是屬於leader的）。

    // Gossip messages with other nodes
    logger.Debugf("[%s] Gossiping block [%d], peers number [%d]", b.chainID, blockNum, numberOfPeers)

    if !b.isDone() {
        // peer節點間通過gossip同步區塊
        b.gossip.Gossip(gossipMsg)
    }

1.4 peer是如何寫區塊

首先，其他peer是通過gossip服務同步區塊，則儲存區塊應該是在gossip服務裡面呼叫的，回到peer啟動時gossip服務的設定

service.GetGossipService().InitializeChannel(bundle.ConfigtxValidator().ChainID(), ordererAddresses, service.Support{
        Validator:            validator,
        Committer:            c,
        Store:                store,
        Cs:                   simpleCollectionStore,
        IdDeserializeFactory: csStoreSupport,
    })
    

裡面會呼叫

    g.chains[chainID] = state.NewGossipStateProvider(chainID, servicesAdapter, coordinator,
        g.metrics.StateMetrics, getStateConfiguration())

裡面會呼叫

    // Listen for incoming communication
    go s.listen()
    // Deliver in order messages into the incoming channel
    go s.deliverPayloads()

deliverPayloads()會將gossip.payload 區塊給寫入賬本。

func (s *GossipStateProviderImpl) deliverPayloads() {
    defer s.done.Done()

    for {
        select {
        // Wait for notification that next seq has arrived
        case <-s.payloads.Ready():
            logger.Debugf("[%s] Ready to transfer payloads (blocks) to the ledger, next block number is = [%d]", s.chainID, s.payloads.Next())
            // Collect all subsequent payloads
            for payload := s.payloads.Pop(); payload != nil; payload = s.payloads.Pop() {
                rawBlock := &common.Block{}
                if err := pb.Unmarshal(payload.Data, rawBlock); err != nil {
                    logger.Errorf("Error getting block with seqNum = %d due to (%+v)...dropping block", payload.SeqNum, errors.WithStack(err))
                    continue
                }
                if rawBlock.Data == nil || rawBlock.Header == nil {
                    logger.Errorf("Block with claimed sequence %d has no header (%v) or data (%v)",
                        payload.SeqNum, rawBlock.Header, rawBlock.Data)
                    continue
                }
                logger.Debugf("[%s] Transferring block [%d] with %d transaction(s) to the ledger", s.chainID, payload.SeqNum, len(rawBlock.Data.Data))

                // Read all private data into slice
                var p util.PvtDataCollections
                if payload.PrivateData != nil {
                    err := p.Unmarshal(payload.PrivateData)
                    if err != nil {
                        logger.Errorf("Wasn't able to unmarshal private data for block seqNum = %d due to (%+v)...dropping block", payload.SeqNum, errors.WithStack(err))
                        continue
                    }
                }
                // 此處會儲存區塊
                if err := s.commitBlock(rawBlock, p); err != nil {
                    if executionErr, isExecutionErr := err.(*vsccErrors.VSCCExecutionFailureError); isExecutionErr {
                        logger.Errorf("Failed executing VSCC due to %v. Aborting chain processing", executionErr)
                        return
                    }
                    logger.Panicf("Cannot commit block to the ledger due to %+v", errors.WithStack(err))
                }
            }
        case <-s.stopCh:
            s.stopCh <- struct{}{}
            logger.Debug("State provider has been stopped, finishing to push new blocks.")
            return
        }
    }
}

總結

1. peer啟動時會啟動gossip服務模組
2. leader啟動gossip服務時會從orderer源源不斷的請求塊
3. peer之間通過gossip同步區塊，當leader獲取區塊後會通過區塊
4. peer當gossip模組中會將gossip.payload區塊資訊寫入賬本
相關推薦

菜鳥系列Fabric原始碼學習 — 區塊同步

Fabric 1.4 原始碼分析 區塊同步 本文主要從原始碼層面介紹fabric peer同步區塊過程，peer同步區塊主要有2個過程： 1）peer組織的leader與orderer同步區塊 2）peer組織間peer同步區塊。 1. peer leader和orderer同步區塊 首先，orderer對外

菜鳥系列Fabric原始碼學習 — committer記賬節點

Fabric 1.4 原始碼分析 committer記賬節點 本文件主要介紹committer記賬節點如何初始化的以及committer記賬節點的功能及其實現。 1. 簡介 記賬節點負責驗證交易和提交賬本，包括公有資料（即區塊資料，包括公共資料和私密資料hash值）與私密資料。在提交賬本前需要驗證交易資料的有

菜鳥系列Fabric原始碼學習 — MVCC驗證

Fabric 1.4 原始碼分析 MVCC驗證 讀本節文件之前建議先檢視[Fabric 1.4 原始碼分析 committer記賬節點]章節。 1. MVCC簡介 Multi-Version Concurrency Control 多版本併發控制，MVCC 是一種併發控制的方法，一般在資料庫管理系統中，實現對

菜鳥系列Fabric——Fabric 動態新增組織（7）

Fabric 網路動態新增組織 1.環境準備 如果存在fabric網路環境可不執行，若不存在可以安裝下列進行準備 下載fabric-sample，fabric https://github.com/hyperledger/fabric-samples.git https://github.com/hype

菜鳥學習Fabric原始碼學習 — Endorser背書節點

Fabric 1.4 原始碼分析 Endorser背書節點 本文件主要介紹fabric背書節點的主要功能及其實現。 1. 簡介 Endorser節點是peer節點所扮演的一種角色，在peer啟動時會建立Endorser背書伺服器，並註冊到本地gRPC伺服器（7051埠）上對外提供服務，對請求的簽名提案訊息執行

菜鳥學習Fabric原始碼學習 — 背書節點和鏈碼容器互動

Fabric 1.4 原始碼分析 背書節點和鏈碼容器互動 本文件主要介紹背書節點和鏈碼容器互動流程，在Endorser背書節點章節中，無論是deploy、upgrade或者呼叫鏈碼，最後都會呼叫ChaincodeSupport.LaunchInit()/Launch()以及ChaincodeSupport.e

菜鳥學習Fabric原始碼學習 — kafka共識機制

Fabric 1.4原始碼分析 kafka共識機制 本文件主要介紹kafka共識機制流程。在檢視文件之前可以先閱覽raft共識流程以及orderer服務啟動流程。 1. kafka 簡介 Kafka是最初由Linkedin公司開發，是一個分散式、分割槽的、多副本的、多訂閱者，基於zookeeper協調的分散式

菜鳥系列之C/C++經典試題(三)

最小 新元素 一道 數據 步驟 時間 name val type 設計包括min函數的棧 題目：定義棧的數據結構，要求加入一個min函數，可以得到棧的最小元素。要求函數min、push以及pop的時間復雜度都是O(1)。 分析：這是2006年google的一道面試題。

Java設計模式菜鳥系列(十五)建造者模式建模與實現

郵箱 system for face tom 建造者模式 data mar 方法 轉載請註明出處：http://blog.csdn.net/lhy_ycu/article/details/39863125 建造者模式(Builder)：工廠類模式提供的

菜鳥系列之C/C++經典試題(五)

span data- 復雜 joseph 暫時 color current sep mod 求圓圈中剩下的最後一個數字 題目：n個數字（0,1,…,n-1）形成一個圓圈，從數字0開始。每次從這個圓圈中刪除第m個數字（第一個為當前數字本身。第二個為當前數字的下一個數

PowerShell 運維菜鳥系列-01-批量為n臺服務器導入PFX證書(2017年除夕奉獻)

use hit stack ans path 域服務器 normal 技術 var 作為PowerShell菜鳥，我用PowerShell已有n年了，不怎麽使用，但積累不少實用的PowerShell腳本。將在後續的工作中一一給大家分享。項目背景:在測試中使用一個公網證書，

PowerShell 運維菜鳥系列-02-批量取n臺Windows KEY（2018年大年初一奉獻）

log margin tac 刪除 階段 運維人員 pen lastlog 9.png 系列博文：PowerShell 運維菜鳥系列-01-批量為n臺服務器導入PFX證書(2017年除夕奉獻) http://blog.51cto.com/dynamic/2071716 項

PowerShell 運維菜鳥系列-03-設置-所有用戶-OWA-時區-語言-跳過-時區設置）

服務器 Lync 項目問題： 新用戶登錄郵箱的OWA的時候，總是要去設置時區，如果是測試，無所謂。 如果是生產，你有幾千人的企業，這樣肯定是不行的。 解決方法： 以下解決方法是一個學生提供，我一直不在意，因為我不管企業的IT，但這對各學生有用，我收集整理在此系列 中。 1. 查用戶 2. 通過Get

菜鳥之路——Python學習之串口通信（與STC89C51）源碼及打包發布試水

方式 lin enc error: pri 打開端口 端口號 兩個 關閉 想做上位機控制系統，就拿51來試試水。 Python環境：Win10+Python 3.6.4（64位）+serial，pyserial 一、上位機程序的編寫 import serial ser =

菜鳥之路——機器學習之HierarchicalClustering層次分析及個人理解

features clu 機器 層次 節點類 均值 成了 range n) 這個算法。我個人感覺有點雞肋。最終的表達也不是特別清楚。 原理很簡單，從所有的樣本中選取Euclidean distance最近的兩個樣本，歸為一類，取其平均值組成一個新樣本，總樣本數少1；不斷的重

萬里長征，始於足下——菜鳥程式設計師的學習總結（一）

目錄： 最近一直的談論如何學習，如何做筆記，學習方法是否正確？（發現問題——創新的原動力）為什麼開始系統化學習了，反而暴露許許多多的問題？細想也並不是很多，這都是過去的遺留問題，就當磨刀不誤砍柴工吧。 學習VB的時候，我原來學習過一遍。第二次再看視訊學習VB，做筆記，畢竟是自己學過一遍的知識，沒有太

【備忘】Java菜鳥到大牛學習路線培訓教程

這是一套Java菜鳥到大牛學習路線培訓教程，由本站工作了10年的資深Java架構師整理。主要分5個階段：Java程式設計師->Java初級軟體工程師->Java中級軟體工程師->Java高階軟體工程師->Java系統架構師，從頭學到尾即可成為大神！

菜鳥成長之Storm學習總結

有一個星期沒有更新啦,說明是好事,至少開始做專案了,把所有的知識點放在專案上,果然會讓人成長的更快;專案的隱私度比較高就不公開了~ 今天總結一下新的內容,學習都有一個過程:從菜鳥到鳥人到大神;所以fighting就對了! 1.離線計算是什麼? 離線

太簡單！只學十分鐘，Python菜鳥也能開發一個區塊鏈客戶端

Java設計模式菜鳥系列(四)工廠方法模式建模與實現

工廠方法模式（Factory Method） 工廠方法：顧名思義，就是呼叫工廠裡的方法來生產物件(產品)的。 工廠方法實現方式有3種： 一、普通工廠模式。就是建立一個工廠類，對實現了同一介面的一些