Golang Logger.Error方法代码示例

func updateIssueReviewLabels(client *github.Client, log log15.Logger, review ReviewRequest) error {
	oldLabels := []string{}
	newLabels := []string{review.CalculateAppropriateStatus()}

	foundReviewLabel, incorrectReviewLabel := false, false

	for _, l := range review.issue.Labels {
		oldLabels = append(oldLabels, *l.Name)

		switch *l.Name {
		case WIPLabel, CakedLabel, AwaitingCakeLabel:
			foundReviewLabel = true

			if *l.Name != newLabels[0] {
				incorrectReviewLabel = true
			}

			continue
		default:
			newLabels = append(newLabels, *l.Name)
		}
	}

	var labelsNeedUpdating bool

	switch {
	case !foundReviewLabel:
		labelsNeedUpdating = true
		log.Info("could not find review label", "old_labels", oldLabels, "new_labels", newLabels)
	case incorrectReviewLabel:
		labelsNeedUpdating = true
		log.Info("review label is incorrect", "old_labels", oldLabels, "new_labels", newLabels)
	default:
		log.Info("review label does not need updating", "labels", oldLabels)
	}

	if labelsNeedUpdating {
		_, _, err := client.Issues.ReplaceLabelsForIssue(*review.repo.Owner.Login, *review.repo.Name, review.Number(), newLabels)

		if err != nil {
			log.Error("unable to update issue review label", "err", err)
			return err
		}
	}

	return nil
}

// NewRaft returns a new raft struct based on the provided configuration
func NewRaft(config *Config, logger log.Logger) (*Raft, error) {

	rand.Seed(time.Now().Unix())

	if config.StateMachine == nil {
		return nil, fmt.Errorf("No state machine configured.")
	}

	inbox := make(chan *channelCmd, 4096)

	// set advertise address, if set
	advertise := config.Bind
	if len(config.Advertise) > 0 {
		advertise = config.Advertise
	}

	logger = logger.New("module", "raft", "server", advertise)

	// cleanup old directories
	if len(config.Peers) != 0 {
		err := os.RemoveAll(config.BaseDir)
		if err != nil {
			return nil, err
		}
	}

	// create basic  directories
	err := os.MkdirAll(config.BaseDir, os.FileMode(0700))
	err = createDirs(config.BaseDir)

	if err != nil {
		logger.Error("Can not create directories", "error", err.Error())
		return nil, err
	}

	// create stable
	stable, err := newBoltDBStable(fmt.Sprintf("%s/logs", config.BaseDir), logger)

	raftRPCImpl := newRaftRPC(logger, inbox)

	// create raft rpc server
	rpcServer, err := multiserver.NewRPCServer(config.Bind, codecFunc, raftRPCImpl, config.TLSConfig, logger)
	if err != nil {
		logger.Error("Can not create rpc server", "error", err.Error())
		return nil, err
	}

	client := NewClient(config.ClientTLSConfig)

	// create peer list without itself
	// at the moment the config is static
	// and needs restart for changes
	peers := make(map[string]*peer)
	for _, server := range config.Peers {
		// check if this instance is in the list
		if server != advertise {
			p := &peer{
				addr:      server,
				timeoutCh: make(chan bool),
				syncing:   false,
			}
			peers[server] = p
		}
	}

	chMap := &channelMap{
		responseWaiter: make(map[uint64]chan interface{}),
		responseResult: make(map[uint64]interface{}),
	}

	vRaft := &Raft{
		peers:       peers,
		state:       Shutdown,
		client:      client,
		appendResCh: make(chan *ResponseAppendEntry, 4096),
		commitCh:    make(chan uint64, 4096),
		inbox:       inbox,
		config:      config,
		channelMap:  chMap,
		stable:      stable,
		logger:      logger,
		advertise:   advertise,
		rpcServer:   rpcServer,
		bind:        config.Bind,
		fsm:         config.StateMachine,
		voteRespCh:  make(chan *ResponseVote, len(peers)),
		commandCh:   make(chan *channelCmd, 4096),
		leaderCh:    make(chan string, 5),
		raftRPC:     raftRPCImpl,
	}

	vRaft.workingSnapshot = &fsmSnapshot{
		LastIndex: 0,
		LastTerm:  0,
	}

	return vRaft, nil
}