mugit @ b4b7c43

···
        36
        36
         	ticker := time.NewTicker(interval)

      
        37
        37
         	defer ticker.Stop()

      
        38
        38
         

      
        39
        
        -	if err := w.mirror(ctx); err != nil {

      
        40
        
        -		slog.Error("initial mirror sync failed", "err", err)

      
        41
        
        -	}

      
        42
        
        -

      
        43
        39
         	for {

      
        44
        40
         		select {

      
        45
        41
         		case <-ctx.Done():

      
        46
        42
         			return nil

      
        47
        
        -		case <-ticker.C:

      
        
        43
        +		default:

      
        48
        44
         			if err := w.mirror(ctx); err != nil {

      
        49
        45
         				slog.Error("mirror sync failed", "err", err)

      
        50
        46
         			}

      
        
        47
        +

      
        
        48
        +			<-ticker.C

      
        51
        49
         		}

      
        52
        50
         	}

      
        53
        51
         }

      ···
        59
        57
         	}

      
        60
        58
         

      
        61
        59
         	var wg sync.WaitGroup

      
        62
        
        -	sem := semaphore.NewWeighted(5)

      
        
        60
        +	sem := semaphore.NewWeighted(10)

      
        63
        61
         	errCh := make(chan error, len(repos))

      
        64
        62
         

      
        65
        63
         	for _, repo := range repos {

      ···
        75
        73
         			}

      
        76
        74
         		})

      
        77
        75
         	}

      
        
        76
        +

      
        78
        77
         	wg.Wait()

      
        79
        78
         	close(errCh)

      
        80
        79
         

      ···
        95
        94
         		return err

      
        96
        95
         	}

      
        97
        96
         

      
        98
        
        -	if err := w.isRemoteValid(remoteURL); err != nil {

      
        
        97
        +	if err := w.isSupportedRemote(remoteURL); err != nil {

      
        99
        98
         		slog.Error("mirror: remote is not valid", "repo", name, "err", err)

      
        100
        99
         		return err

      
        101
        100
         	}

      
        102
        101
         

      
        103
        102
         	if w.isRemoteGithub(remoteURL) && w.c.Mirror.GithubToken != "" {

      
        104
        103
         		if err := repo.FetchFromGithubWithToken(w.c.Mirror.GithubToken); err != nil {

      
        105
        
        -			slog.Error("mirror: fetch failed (authorized)", "repo", name, "err", err)

      
        
        104
        +			slog.Error("mirror: fetch failed (github)", "repo", name, "err", err)

      
        106
        105
         			return err

      
        107
        106
         		}

      
        108
        107
         	} else {

      ···
        133
        132
         		}

      
        134
        133
         

      
        135
        134
         		name := dir.Name()

      
        136
        
        -		repo, err := git.Open(filepath.Join(w.c.Repo.Dir, filepath.Clean(name)), "")

      
        
        135
        +		path := filepath.Join(w.c.Repo.Dir, filepath.Clean(name))

      
        
        136
        +		repo, err := git.Open(path, "")

      
        137
        137
         		if err != nil {

      
        138
        
        -			slog.Debug("skipping non-git directory", "path", name, "err", err)

      
        
        138
        +			slog.Debug("skipping non-git directory", "name", name, "err", err)

      
        139
        139
         			continue

      
        140
        140
         		}

      
        141
        141
         

      
        142
        142
         		isMirror, err := repo.IsMirror()

      
        143
        143
         		if err != nil {

      
        144
        
        -			slog.Debug("skipping non-mirror repo", "path", name, "err", err)

      
        
        144
        +			slog.Debug("skipping non-mirror repo", "name", name, "err", err)

      
        145
        145
         			continue

      
        146
        146
         		}

      
        147
        147
         

      ···
        153
        153
         	return repos, nil

      
        154
        154
         }

      
        155
        155
         

      
        156
        
        -func (w *Worker) isRemoteValid(remote string) error {

      
        
        156
        +func (w *Worker) isSupportedRemote(remote string) error {

      
        157
        157
         	if !strings.HasPrefix(remote, "http") {

      
        158
        158
         		return fmt.Errorf("only http and https remotes are supported")

      
        159
        159
         	}