fixed issue (#19), add retry option for fetch post list

kemono/fetch.go

@@ -46,19 +46,18 @@ func (k *Kemono) FetchPosts(service, id string) (posts []Post, err error) {
 		purl := fmt.Sprintf("%s?o=%d", url, page*perUnit)
 
 		retryCount := 0
-		for retryCount < 3 {
+		for retryCount < k.retry {
 			resp, err := k.Downloader.Get(purl)
 			if err != nil {
 				k.log.Printf("fetch post list error: %v", err)
-				// Sleep for 5 seconds before retrying
-				time.Sleep(5 * time.Second)
+				time.Sleep(k.retryInterval)
 				retryCount++
 				continue
 			}
 
 			if resp.StatusCode != http.StatusOK {
 				k.log.Printf("fetch post list error: %s", resp.Status)
-				time.Sleep(5 * time.Second)
+				time.Sleep(k.retryInterval)
 				retryCount++
 				continue
 			}

kemono/kemono.go

@@ -67,6 +67,10 @@ type Kemono struct {
 	Downloader Downloader
 
 	log Log
+
+	retry int
+
+	retryInterval time.Duration
 }
 
 func NewKemono(options ...Option) *Kemono {
@@ -75,6 +79,8 @@ func NewKemono(options ...Option) *Kemono {
 		Banner:            true,
 		postFilters:       make(map[string][]PostFilter),
 		attachmentFilters: make(map[string][]AttachmentFilter),
+		retry:             3,
+		retryInterval:     5 * time.Second,
 	}
 	for _, option := range options {
 		option(k)
@@ -162,6 +168,20 @@ func SetLog(log Log) Option {
 	}
 }
 
+// SetRetry set retry
+func SetRetry(retry int) Option {
+	return func(k *Kemono) {
+		k.retry = retry
+	}
+}
+
+// SetRetryInterval set retry interval
+func SetRetryInterval(retryInterval time.Duration) Option {
+	return func(k *Kemono) {
+		k.retryInterval = retryInterval
+	}
+}
+
 // WithCreatorFilter Creator filter
 func WithCreatorFilter(filter ...CreatorFilter) Option {
 	return func(k *Kemono) {

main/main.go

@@ -346,12 +346,14 @@ func main() {
 		log.Fatalf("retry must be greater than 0")
 	} else {
 		downloaderOptions = append(downloaderOptions, downloader.Retry(retry))
+		sharedOptions = append(sharedOptions, kemono.SetRetry(retry))
 	}
 
 	if retryInterval < 0 {
 		log.Fatalf("retry interval must be greater than 0")
 	} else {
 		downloaderOptions = append(downloaderOptions, downloader.RetryInterval(time.Duration(retryInterval)*time.Second))
+		sharedOptions = append(sharedOptions, kemono.SetRetryInterval(time.Duration(retryInterval)*time.Second))
 	}
 
 	// check maxDownloadGoroutine
@@ -559,19 +561,19 @@ func setFlag() {
 		date = config["date"].(int)
 	}
 	if !passedFlags["date-before"] && config["date-before"] != nil {
-		date = config["date-before"].(int)
+		dateBefore = config["date-before"].(int)
 	}
 	if !passedFlags["date-after"] && config["date-after"] != nil {
-		date = config["date-after"].(int)
+		dateAfter = config["date-after"].(int)
 	}
 	if !passedFlags["update"] && config["update"] != nil {
 		update = config["update"].(int)
 	}
 	if !passedFlags["update-before"] && config["update-before"] != nil {
-		update = config["update-before"].(int)
+		updateBefore = config["update-before"].(int)
 	}
 	if !passedFlags["update-after"] && config["update-after"] != nil {
-		update = config["update-after"].(int)
+		updateAfter = config["update-after"].(int)
 	}
 	if !passedFlags["extension-only"] && config["extension-only"] != nil {
 		extensionOnly = config["extension-only"].(string)
@@ -689,12 +691,12 @@ func fetchFavoriteCreators(s string, cookie []*http.Cookie) []kemono.FavoriteCre
 	if resp.StatusCode != 200 {
 		log.Fatalf("Error getting favorites: %d", resp.StatusCode)
 	}
-	var creators []kemono.FavoriteCreator
-	err = json.NewDecoder(resp.Body).Decode(&creators)
+	var favoriteCreators []kemono.FavoriteCreator
+	err = json.NewDecoder(resp.Body).Decode(&favoriteCreators)
 	if err != nil {
 		log.Fatalf("Error decoding favorites: %s", err)
 	}
-	return creators
+	return favoriteCreators
 }
 
 func fetchFavoritePosts(s string, cookie []*http.Cookie) []kemono.PostRaw {