//
// Callback when a new proposal arrives
//
func (s *Server) UpdateStateOnNewProposal(proposal protocol.ProposalMsg) {
fid := proposal.GetFid()
reqId := proposal.GetReqId()
txnid := proposal.GetTxnid()
// If this host is the one that sends the request to the leader
if fid == s.handler.GetFollowerId() {
s.state.mutex.Lock()
defer s.state.mutex.Unlock()
// look up the request handle from the pending list and
// move it to the proposed list
handle, ok := s.state.pendings[reqId]
if ok {
delete(s.state.pendings, reqId)
s.state.proposals[common.Txnid(txnid)] = handle
}
}
}
//
// Update the request upon new proposal.
//
func (c *Coordinator) updateRequestOnNewProposal(proposal protocol.ProposalMsg) {
fid := proposal.GetFid()
reqId := proposal.GetReqId()
txnid := proposal.GetTxnid()
logging.Debugf("Coorindator.updateRequestOnNewProposal(): recieve proposal. Txnid %d, follower id %s, coorindator fid %s",
txnid, fid, c.GetFollowerId())
// If this host is the one that sends the request to the leader
if fid == c.GetFollowerId() {
c.state.mutex.Lock()
defer c.state.mutex.Unlock()
// look up the request handle from the pending list and
// move it to the proposed list
handle, ok := c.state.pendings[reqId]
if ok {
delete(c.state.pendings, reqId)
c.state.proposals[common.Txnid(txnid)] = handle
}
}
}
func (w *watcher) LogProposal(p protocol.ProposalMsg) error {
w.mutex.Lock()
defer w.mutex.Unlock()
msg := w.factory.CreateLogEntry(p.GetTxnid(), p.GetOpCode(), p.GetKey(), p.GetContent())
w.pendings[common.Txnid(p.GetTxnid())] = msg
handle, ok := w.pendingReqs[p.GetReqId()]
if ok {
delete(w.pendingReqs, p.GetReqId())
w.loggedReqs[common.Txnid(p.GetTxnid())] = handle
}
return nil
}
// TODO : what to do if createIndex returns error
func (c *Coordinator) LogProposal(proposal protocol.ProposalMsg) error {
if c.GetStatus() == protocol.LEADING {
switch common.OpCode(proposal.GetOpCode()) {
case OPCODE_ADD_IDX_DEFN:
success := c.createIndex(proposal.GetKey(), proposal.GetContent())
logging.Debugf("Coordinator.LogProposal(): (createIndex) success = %s", success)
case OPCODE_DEL_IDX_DEFN:
success := c.deleteIndex(proposal.GetKey())
logging.Debugf("Coordinator.LogProposal(): (deleteIndex) success = %s", success)
}
}
switch common.OpCode(proposal.GetOpCode()) {
case OPCODE_NOTIFY_TIMESTAMP:
timestamp, err := unmarshallTimestampSerializable(proposal.GetContent())
if err == nil {
c.idxMgr.notifyNewTimestamp(timestamp)
} else {
logging.Debugf("Coordinator.LogProposal(): error when unmarshalling timestamp. Ignore timestamp. Error=%s", err.Error())
}
}
c.updateRequestOnNewProposal(proposal)
return nil
}
func (s *watcher) UpdateStateOnNewProposal(proposal protocol.ProposalMsg) {
s.mutex.Lock()
defer s.mutex.Unlock()
opCode := common.OpCode(proposal.GetOpCode())
logging.Debugf("Watcher.UpdateStateOnNewProposal(): receive proposal on metadata kind %d", findTypeFromKey(proposal.GetKey()))
// register the event for notification
var evtType EventType = EVENT_NONE
switch opCode {
case common.OPCODE_ADD:
metaType := findTypeFromKey(proposal.GetKey())
if metaType == KIND_INDEX_DEFN {
evtType = EVENT_CREATE_INDEX
} else if metaType == KIND_TOPOLOGY {
evtType = EVENT_UPDATE_TOPOLOGY
}
case common.OPCODE_SET:
metaType := findTypeFromKey(proposal.GetKey())
if metaType == KIND_INDEX_DEFN {
evtType = EVENT_CREATE_INDEX
} else if metaType == KIND_TOPOLOGY {
evtType = EVENT_UPDATE_TOPOLOGY
}
case common.OPCODE_DELETE:
if findTypeFromKey(proposal.GetKey()) == KIND_INDEX_DEFN {
evtType = EVENT_DROP_INDEX
}
default:
logging.Debugf("Watcher.UpdateStateOnNewProposal(): recieve proposal with opcode %d. Skip convert proposal to event.", opCode)
}
logging.Debugf("Watcher.UpdateStateOnNewProposal(): convert metadata type to event %d", evtType)
if evtType != EVENT_NONE {
logging.Debugf("Watcher.UpdateStateOnNewProposal(): register event for txid %d", proposal.GetTxnid())
s.notifications[common.Txnid(proposal.GetTxnid())] =
newNotificationHandle(proposal.GetKey(), evtType, proposal.GetContent())
}
}
func (a *ServerAction) LogProposal(p protocol.ProposalMsg) error {
if a.notifier != nil {
tnxid, op, key, content := p.GetTxnid(), p.GetOpCode(), p.GetKey(), p.GetContent()
if err := a.notifier.OnNewProposal(common.Txnid(tnxid), common.OpCode(op), key, content); err != nil {
return err
}
}
err := a.appendCommitLog(common.Txnid(p.GetTxnid()), common.OpCode(p.GetOpCode()), p.GetKey(), p.GetContent())
if err != nil {
return err
}
a.server.UpdateStateOnNewProposal(p)
return nil
}
