// // Bootstrp // func (s *Server) bootstrap() (err error) { // Initialize server state s.state = newServerState() // Initialize repository service s.repo, err = r.OpenRepository() if err != nil { return err } s.log = r.NewCommitLog(s.repo) s.srvConfig = r.NewServerConfig(s.repo) // Create and initialize new txn state. s.txn = common.NewTxnState() // initialize the current transaction id to the lastLoggedTxid. This // is the txid that this node has seen so far. If this node becomes // the leader, a new epoch will be used and new current txid will // be generated. So no need to initialize the epoch at this point. lastLoggedTxid, err := s.srvConfig.GetLastLoggedTxnId() if err != nil { return err } s.txn.InitCurrentTxnid(common.Txnid(lastLoggedTxid)) // Initialize various callback facility for leader election and // voting protocol. s.factory = message.NewConcreteMsgFactory() s.handler = action.NewServerAction(s.repo, s.log, s.srvConfig, s, s.txn, s.factory, s) s.skillch = make(chan bool, 1) // make it buffered to unblock sender s.site = nil // Need to start the peer listener before election. A follower may // finish its election before a leader finishes its election. Therefore, // a follower node can request a connection to the leader node before that // node knows it is a leader. By starting the listener now, it allows the // follower to establish the connection and let the leader handles this // connection at a later time (when it is ready to be a leader). s.listener, err = common.StartPeerListener(GetHostTCPAddr()) if err != nil { return common.WrapError(common.SERVER_ERROR, "Fail to start PeerListener.", err) } // Start a request listener. s.reqListener, err = StartRequestListener(GetHostRequestAddr(), s) if err != nil { return common.WrapError(common.SERVER_ERROR, "Fail to start RequestListener.", err) } return nil }
func (s *fakeServer) bootstrap() (err error) { // Initialize repository service s.repo, err = repo.OpenRepository() if err != nil { return err } s.txn = common.NewTxnState() s.factory = message.NewConcreteMsgFactory() s.handler = action.NewDefaultServerAction(s.repo, s, s.txn) s.killch = make(chan bool, 1) // make it buffered to unblock sender s.status = protocol.ELECTING return nil }
func newRemoteRepoRef(requestAddr string, leaderAddr string, config string, mgr *IndexManager) (*RemoteRepoRef, error) { // Initialize local repository repository, err := repo.OpenRepository() if err != nil { return nil, err } // This is a blocking call unit the watcher is ready. This means // the watcher has succesfully synchronized with the remote metadata // repository. var watcherId string env, err := newEnv(config) if err == nil { watcherId = env.getHostElectionPort() } else { uuid, err := common.NewUUID() if err != nil { return nil, err } watcherId = strconv.FormatUint(uuid.Uint64(), 10) } watcher, err := startWatcher(mgr, repository, leaderAddr, watcherId) if err != nil { return nil, err } repoRef := &RemoteRepoRef{remoteReqAddr: requestAddr, repository: repository, watcher: watcher} return repoRef, nil }