Golang internal.Command類代碼示例

func (fsm *storeFSM) Apply(l *raft.Log) interface{} {
	var cmd internal.Command
	if err := proto.Unmarshal(l.Data, &cmd); err != nil {
		panic(fmt.Errorf("cannot marshal command: %x", l.Data))
	}

	// Lock the store.
	s := (*Store)(fsm)
	s.mu.Lock()
	defer s.mu.Unlock()

	err := func() interface{} {
		switch cmd.GetType() {
		case internal.Command_CreateNodeCommand:
			return fsm.applyCreateNodeCommand(&cmd)
		case internal.Command_DeleteNodeCommand:
			return fsm.applyDeleteNodeCommand(&cmd)
		case internal.Command_CreateDatabaseCommand:
			return fsm.applyCreateDatabaseCommand(&cmd)
		case internal.Command_DropDatabaseCommand:
			return fsm.applyDropDatabaseCommand(&cmd)
		case internal.Command_CreateRetentionPolicyCommand:
			return fsm.applyCreateRetentionPolicyCommand(&cmd)
		case internal.Command_DropRetentionPolicyCommand:
			return fsm.applyDropRetentionPolicyCommand(&cmd)
		case internal.Command_SetDefaultRetentionPolicyCommand:
			return fsm.applySetDefaultRetentionPolicyCommand(&cmd)
		case internal.Command_UpdateRetentionPolicyCommand:
			return fsm.applyUpdateRetentionPolicyCommand(&cmd)
		case internal.Command_CreateShardGroupCommand:
			return fsm.applyCreateShardGroupCommand(&cmd)
		case internal.Command_DeleteShardGroupCommand:
			return fsm.applyDeleteShardGroupCommand(&cmd)
		case internal.Command_CreateContinuousQueryCommand:
			return fsm.applyCreateContinuousQueryCommand(&cmd)
		case internal.Command_DropContinuousQueryCommand:
			return fsm.applyDropContinuousQueryCommand(&cmd)
		case internal.Command_CreateUserCommand:
			return fsm.applyCreateUserCommand(&cmd)
		case internal.Command_DropUserCommand:
			return fsm.applyDropUserCommand(&cmd)
		case internal.Command_UpdateUserCommand:
			return fsm.applyUpdateUserCommand(&cmd)
		case internal.Command_SetPrivilegeCommand:
			return fsm.applySetPrivilegeCommand(&cmd)
		case internal.Command_SetAdminPrivilegeCommand:
			return fsm.applySetAdminPrivilegeCommand(&cmd)
		case internal.Command_SetDataCommand:
			return fsm.applySetDataCommand(&cmd)
		default:
			panic(fmt.Errorf("cannot apply command: %x", l.Data))
		}
	}()

	// Copy term and index to new metadata.
	fsm.data.Term = l.Term
	fsm.data.Index = l.Index

	return err
}

func main() {
	qlog.SetOutputLevel(0)
	db, err := raftboltdb.NewBoltStore(PATH)
	lastIdx, err := db.LastIndex()
	firtIdx, err := db.FirstIndex()
	for i := int(firtIdx); i <= int(lastIdx); i++ {
		log := new(raft.Log)
		if err = db.GetLog(uint64(i), log); err != nil {
			qlog.Debug(err)
			continue
		}

		switch log.Type {
		case raft.LogCommand:
			qlog.Info("The raftlog type is LogCommand")
			var cmd internal.Command
			if err := proto.Unmarshal(log.Data, &cmd); err != nil {
				qlog.Debug(err)
				continue
			}
			command := cmd.GetType()
			qlog.Infof("The command is: %s", command)
			if command == internal.Command_CreateNodeCommand {
				ext, _ := proto.GetExtension(&cmd, internal.E_CreateNodeCommand_Command)
				v, ok := ext.(*internal.CreateNodeCommand)
				if !ok {
					continue
				}
				qlog.Debug("v.GetHost()", v.GetHost())
			}

			if command == internal.Command_CreateDatabaseCommand {
				ext, _ := proto.GetExtension(&cmd, internal.E_CreateDatabaseCommand_Command)
				v, ok := ext.(*internal.CreateDatabaseCommand)
				if !ok {
					continue
				}
				qlog.Debug("v.GetName()", v.GetName())
				qlog.Debug("v.String()", v.String())
			}

			if command == internal.Command_CreateRetentionPolicyCommand {
				ext, _ := proto.GetExtension(&cmd, internal.E_CreateRetentionPolicyCommand_Command)
				v, ok := ext.(*internal.CreateRetentionPolicyCommand)
				if !ok {
					continue
				}
				qlog.Debug("v.GetDatabase()", v.GetDatabase())
				qlog.Debug("v.GetRetentionPolicy()", v.GetRetentionPolicy())
				qlog.Debug("v.String()", v.String())
			}

			if command == internal.Command_SetDefaultRetentionPolicyCommand {
				ext, _ := proto.GetExtension(&cmd, internal.E_SetDefaultRetentionPolicyCommand_Command)
				v, ok := ext.(*internal.SetDefaultRetentionPolicyCommand)
				if !ok {
					continue
				}
				qlog.Debug("v.GetDatabase()", v.GetDatabase())
				qlog.Debug("v.GetName()", v.GetName())
				qlog.Debug("v.String()", v.String())
			}

		case raft.LogNoop:
			qlog.Info("The raftlog type is LogNoop")
		case raft.LogAddPeer:
			qlog.Info("The raftlog type is LogAddPeer")
			peers := decodePeers(log.Data)

			if len(peers) == 0 {
				qlog.Debug("peers == 0")
				continue
			}
			qlog.Infof("peers is:%s", peers)

		case raft.LogRemovePeer:
			qlog.Info("The raftlog type is LogAddPeer")
		}
	}
	return
}