func (s *Server) generateViewSequenceWithConsensus(associatedView *view.View, seq ViewSeq) {
	assertOnlyUpdatedViews(associatedView, seq)

	if associatedView.GetProcessPosition(s.thisProcess) == CONSENSUS_LEADER_PROCESS_POSITION {
		consensus.Propose(associatedView, s.thisProcess, &seq)
	}
	log.Println("Waiting for consensus resolution")
	value := <-consensus.GetConsensusResultChan(associatedView)

	// get startReconfigurationTime to compute reconfiguration duration
	//if startReconfigurationTime.IsZero() || startReconfigurationTime.Sub(time.Now()) > 20*time.Second {
	//startReconfigurationTime = consensus.GetConsensusStartTime(associatedView)
	//log.Println("starttime :", startReconfigurationTime)
	//}

	result, ok := value.(*ViewSeq)
	if !ok {
		log.Fatalf("FATAL: consensus on generateViewSequenceWithConsensus got %T %v\n", value, value)
	}
	log.Println("Consensus result received")

	s.generatedViewSeqChan <- generatedViewSeq{
		AssociatedView: associatedView,
		ViewSeq:        *result,
	}
}

func broadcastAcceptRequest(destinationView *view.View, proposal Proposal, resultChan chan Proposal) {
	for _, process := range destinationView.GetMembers() {
		go func(process view.Process) {
			var result Proposal
			err := comm.SendRPCRequest(process, "ConsensusRequest.Accept", proposal, &result)
			if err != nil {
				resultChan <- Proposal{Err: err}
				return
			}
			resultChan <- result
		}(process)
	}
}

func (s *Server) updateCurrentViewLocked(newView *view.View) {
	if !newView.MoreUpdatedThan(s.currentView) {
		// comment these log messages; they are just for debugging
		if newView.LessUpdatedThan(s.currentView) {
			log.Println("WARNING: Tried to Update current view with a less updated view")
		} else {
			log.Println("WARNING: Tried to Update current view with the same view")
		}
		return
	}

	s.currentView = newView
	log.Printf("CurrentView updated to: %v, ref: %v\n", s.currentView, s.currentView.ViewRef)
}

// BroadcastRPCRequest invokes serviceMethod at all members of the
// destinationView with arg. It returns an error if it fails to receive
// a response from a quorum of processes.
func BroadcastRPCRequest(destinationView *view.View, serviceMethod string, arg interface{}) error {
	errorChan := make(chan error, destinationView.NumberOfMembers())

	for _, process := range destinationView.GetMembers() {
		go func(process view.Process) {
			var discardResult struct{}
			errorChan <- SendRPCRequest(process, serviceMethod, arg, &discardResult)
		}(process)
	}

	failedTotal := 0
	successTotal := 0
	for {
		err := <-errorChan

		if err != nil {
			failedTotal++
			if failedTotal > destinationView.NumberOfToleratedFaults() {
				log.Printf("WARN: BroadcastRPCRequest failed to send %v to a quorum\n", serviceMethod)
				return err
			}
		} else {
			successTotal++
			if successTotal == destinationView.QuorumSize() {
				return nil
			}
		}
	}
}

func getOrCreateConsensus(associatedView *view.View) consensusInstance {
	consensusTableMu.Lock()
	defer consensusTableMu.Unlock()

	ci, ok := consensusTable[associatedView.NumberOfUpdates()]
	if !ok {
		ci = consensusInstance{associatedView: associatedView, taskChan: make(chan consensusTask, CHANNEL_DEFAULT_BUFFER_SIZE), callbackLearnChan: make(chan interface{}, 1)}
		//ci.startTime = time.Now()
		consensusTable[associatedView.NumberOfUpdates()] = ci
		log.Println("Created consensus instance:", ci)

		go consensusWorker(ci)
	}
	return ci
}

func broadcastWrite(destinationView *view.View, writeMsg RegisterMsg, resultChan chan RegisterMsg) {
	for _, process := range destinationView.GetMembers() {
		go sendWrite(process, &writeMsg, resultChan)
	}
}

func broadcastRead(destinationView *view.View, viewRef view.ViewRef, resultChan chan RegisterMsg) {
	for _, process := range destinationView.GetMembers() {
		go sendRead(process, viewRef, resultChan)
	}
}

// getNextProposalNumber to be used by this process. This function is a stage of the Propose funcion.
func getNextProposalNumber(associatedView *view.View, thisProcess view.Process) (proposalNumber int) {
	if associatedView.NumberOfMembers() == 0 {
		log.Fatalln("associatedView is empty")
	}

	thisProcessPosition := associatedView.GetProcessPosition(thisProcess)

	lastProposalNumber, err := getLastProposalNumber(associatedView.NumberOfUpdates())
	if err != nil {
		proposalNumber = associatedView.NumberOfMembers() + thisProcessPosition
	} else {
		proposalNumber = (lastProposalNumber - (lastProposalNumber % associatedView.NumberOfMembers()) + associatedView.NumberOfMembers()) + thisProcessPosition
	}

	saveProposalNumberOnStorage(associatedView.NumberOfUpdates(), proposalNumber)
	return
}

// -------- Broadcast functions -----------
func broadcastViewSequence(destinationView *view.View, viewSeqMsg ViewSeqMsg) {
	destinationViewWithoutThisProcess := destinationView.NewCopyWithUpdates(view.Update{Type: view.Leave, Process: globalServer.thisProcess})
	comm.BroadcastRPCRequest(destinationViewWithoutThisProcess, "ViewGeneratorRequest.ProposeSeqView", viewSeqMsg)
}