280 lines
9.4 KiB
Go
Executable file
280 lines
9.4 KiB
Go
Executable file
package main
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
var imageSearchEngines []SearchEngine
|
|
|
|
func init() {
|
|
imageSearchEngines = []SearchEngine{
|
|
{Name: "Qwant", Func: wrapImageSearchFunc(PerformQwantImageSearch)},
|
|
{Name: "Bing", Func: wrapImageSearchFunc(PerformBingImageSearch)},
|
|
{Name: "DeviantArt", Func: wrapImageSearchFunc(PerformDeviantArtImageSearch)},
|
|
//{Name: "Imgur", Func: wrapImageSearchFunc(PerformImgurImageSearch), Weight: 4}, // Image proxy not working
|
|
}
|
|
}
|
|
|
|
func handleImageSearch(w http.ResponseWriter, r *http.Request, settings UserSettings, query string, page int) {
|
|
startTime := time.Now()
|
|
|
|
cacheKey := CacheKey{
|
|
Query: query,
|
|
Page: page,
|
|
Safe: settings.SafeSearch == "active",
|
|
Lang: settings.SearchLanguage,
|
|
Type: "image",
|
|
}
|
|
|
|
// Check if JavaScript is disabled
|
|
jsDisabled := r.URL.Query().Get("js_disabled") == "true"
|
|
|
|
// Determine if we should cache images synchronously
|
|
synchronous := jsDisabled
|
|
|
|
combinedResults := getImageResultsFromCacheOrFetch(cacheKey, query, settings.SafeSearch, settings.SearchLanguage, page, synchronous)
|
|
|
|
elapsedTime := time.Since(startTime)
|
|
|
|
// Prepare the data to pass to the template
|
|
data := map[string]interface{}{
|
|
"Results": combinedResults,
|
|
"Query": query,
|
|
"Fetched": fmt.Sprintf("%.2f %s", elapsedTime.Seconds(), Translate("seconds")),
|
|
"Page": page,
|
|
"HasPrevPage": page > 1,
|
|
"HasNextPage": len(combinedResults) >= 50,
|
|
"NoResults": len(combinedResults) == 0,
|
|
"LanguageOptions": languageOptions,
|
|
"CurrentLang": settings.SearchLanguage,
|
|
"Theme": settings.Theme,
|
|
"Safe": settings.SafeSearch,
|
|
"IsThemeDark": settings.IsThemeDark,
|
|
"HardCacheEnabled": config.DriveCacheEnabled,
|
|
"JsDisabled": jsDisabled,
|
|
}
|
|
|
|
if r.URL.Query().Get("ajax") == "true" {
|
|
// Render only the images
|
|
renderTemplate(w, "images_only.html", data)
|
|
return
|
|
}
|
|
|
|
// Render the full page
|
|
renderTemplate(w, "images.html", data)
|
|
}
|
|
|
|
func getImageResultsFromCacheOrFetch(cacheKey CacheKey, query, safe, lang string, page int, synchronous bool) []ImageSearchResult {
|
|
cacheChan := make(chan []SearchResult)
|
|
var combinedResults []ImageSearchResult
|
|
|
|
go func() {
|
|
results, exists := resultsCache.Get(cacheKey)
|
|
if exists {
|
|
printDebug("Cache hit")
|
|
cacheChan <- results
|
|
} else {
|
|
printDebug("Cache miss")
|
|
cacheChan <- nil
|
|
}
|
|
}()
|
|
|
|
select {
|
|
case results := <-cacheChan:
|
|
if results == nil {
|
|
if config.MetaSearchEnabled {
|
|
combinedResults = fetchImageResults(query, safe, lang, page, synchronous)
|
|
if len(combinedResults) > 0 {
|
|
combinedResults = filterValidImages(combinedResults)
|
|
resultsCache.Set(cacheKey, convertToSearchResults(combinedResults))
|
|
}
|
|
} else {
|
|
printDebug("Crawler disabled; skipping fetching from image search engines.")
|
|
}
|
|
} else {
|
|
_, _, imageResults, _ := convertToSpecificResults(results)
|
|
combinedResults = filterValidImages(imageResults)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
printDebug("Cache check timeout")
|
|
if config.MetaSearchEnabled {
|
|
combinedResults = fetchImageResults(query, safe, lang, page, synchronous)
|
|
if len(combinedResults) > 0 {
|
|
combinedResults = filterValidImages(combinedResults)
|
|
resultsCache.Set(cacheKey, convertToSearchResults(combinedResults))
|
|
}
|
|
} else {
|
|
printDebug("Crawler disabled; skipping fetching from image search engines.")
|
|
}
|
|
}
|
|
|
|
return combinedResults
|
|
}
|
|
|
|
func fetchImageResults(query, safe, lang string, page int, synchronous bool) []ImageSearchResult {
|
|
var results []ImageSearchResult
|
|
|
|
// Check if MetaSearchEnabled is false
|
|
if !config.MetaSearchEnabled {
|
|
printDebug("Crawler is disabled; skipping image search engine fetching.")
|
|
return results
|
|
}
|
|
|
|
engineCount := len(imageSearchEngines)
|
|
|
|
// Determine the engine to use based on the page number
|
|
engineIndex := (page - 1) % engineCount
|
|
engine := imageSearchEngines[engineIndex]
|
|
|
|
// Calculate the specific page number for the selected engine
|
|
enginePage := (page-1)/engineCount + 1
|
|
|
|
// Fetch results from the selected engine
|
|
searchResults, _, err := engine.Func(query, safe, lang, enginePage)
|
|
if err != nil {
|
|
printWarn("Error performing image search with %s: %v", engine.Name, err)
|
|
} else {
|
|
for _, result := range searchResults {
|
|
imageResult := result.(ImageSearchResult)
|
|
|
|
// Skip image if thumbnail URL is empty
|
|
if imageResult.Thumb == "" {
|
|
printWarn("Skipping image with empty thumbnail URL. Full URL: %s", imageResult.Full)
|
|
continue
|
|
}
|
|
|
|
// Generate hash and set up caching
|
|
hasher := md5.New()
|
|
hasher.Write([]byte(imageResult.Full))
|
|
hash := hex.EncodeToString(hasher.Sum(nil))
|
|
imageResult.ID = hash
|
|
|
|
// Store mapping from imageID_full and imageID_thumb to URLs
|
|
imageURLMapMu.Lock()
|
|
imageURLMap[fmt.Sprintf("%s_full", hash)] = imageResult.Full
|
|
imageURLMap[fmt.Sprintf("%s_thumb", hash)] = imageResult.Thumb
|
|
imageURLMapMu.Unlock()
|
|
|
|
// Set ProxyFull and ProxyThumb
|
|
if config.DriveCacheEnabled {
|
|
// Cache the thumbnail image asynchronously
|
|
go func(imgResult ImageSearchResult) {
|
|
_, success, err := cacheImage(imgResult.Thumb, imgResult.ID, true)
|
|
if err != nil || !success {
|
|
printWarn("Failed to cache thumbnail image %s: %v", imgResult.Thumb, err)
|
|
removeImageResultFromCache(query, page, safe == "active", lang, imgResult.ID)
|
|
}
|
|
}(imageResult)
|
|
|
|
// Set ProxyThumb to the proxy URL (initially placeholder)
|
|
imageResult.ProxyThumb = fmt.Sprintf("/image/%s_thumb.webp", hash)
|
|
|
|
// Set ProxyFull to the proxy URL
|
|
imageResult.ProxyFull = fmt.Sprintf("/image/%s_full", hash)
|
|
} else {
|
|
// Hard cache disabled, proxy both thumb and full images
|
|
imageResult.ProxyThumb = fmt.Sprintf("/image/%s_thumb", hash)
|
|
imageResult.ProxyFull = fmt.Sprintf("/image/%s_full", hash)
|
|
}
|
|
|
|
results = append(results, imageResult)
|
|
}
|
|
}
|
|
|
|
// Fallback mechanism if no results are fetched from the selected engine
|
|
if len(results) == 0 {
|
|
printWarn("No image results found with engine %s, trying other engines.", engine.Name)
|
|
for i := 1; i < engineCount; i++ {
|
|
nextEngine := imageSearchEngines[(engineIndex+i)%engineCount]
|
|
enginePage = (page-1)/engineCount + 1 // Recalculate page for next engine
|
|
printInfo("Trying next image search engine: %s (engine page %d)", nextEngine.Name, enginePage)
|
|
|
|
searchResults, _, err := nextEngine.Func(query, safe, lang, enginePage)
|
|
if err != nil {
|
|
printWarn("Error performing image search with %s: %v", nextEngine.Name, err)
|
|
continue
|
|
}
|
|
for _, result := range searchResults {
|
|
imageResult := result.(ImageSearchResult)
|
|
|
|
// Skip image if thumbnail URL is empty
|
|
if imageResult.Thumb == "" {
|
|
printWarn("Skipping image with empty thumbnail URL. Full URL: %s", imageResult.Full)
|
|
continue
|
|
}
|
|
|
|
// Generate hash and set up caching
|
|
hasher := md5.New()
|
|
hasher.Write([]byte(imageResult.Full))
|
|
hash := hex.EncodeToString(hasher.Sum(nil))
|
|
imageResult.ID = hash
|
|
|
|
// Store mapping from imageID_full and imageID_thumb to URLs
|
|
imageURLMapMu.Lock()
|
|
imageURLMap[fmt.Sprintf("%s_full", hash)] = imageResult.Full
|
|
imageURLMap[fmt.Sprintf("%s_thumb", hash)] = imageResult.Thumb
|
|
imageURLMapMu.Unlock()
|
|
|
|
if config.DriveCacheEnabled {
|
|
// Cache the thumbnail image asynchronously
|
|
go func(imgResult ImageSearchResult) {
|
|
_, success, err := cacheImage(imgResult.Thumb, imgResult.ID, true)
|
|
if err != nil || !success {
|
|
printWarn("Failed to cache thumbnail image %s: %v", imgResult.Thumb, err)
|
|
removeImageResultFromCache(query, page, safe == "active", lang, imgResult.ID)
|
|
}
|
|
}(imageResult)
|
|
|
|
// Set ProxyThumb to the proxy URL (initially placeholder)
|
|
imageResult.ProxyThumb = fmt.Sprintf("/image/%s_thumb.webp", hash)
|
|
|
|
// Set ProxyFull to the proxy URL
|
|
imageResult.ProxyFull = fmt.Sprintf("/image/%s_full", hash)
|
|
} else {
|
|
// Hard cache disabled, proxy both thumb and full images
|
|
imageResult.ProxyThumb = fmt.Sprintf("/image/%s_thumb", hash)
|
|
imageResult.ProxyFull = fmt.Sprintf("/image/%s_full", hash)
|
|
}
|
|
|
|
results = append(results, imageResult)
|
|
}
|
|
|
|
if len(results) > 0 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// // Filter out images that failed to cache or are invalid
|
|
// validResults := make([]ImageSearchResult, 0, len(results))
|
|
// for _, imageResult := range results {
|
|
// if imageResult.ProxyFull != "" {
|
|
// validResults = append(validResults, imageResult)
|
|
// } else {
|
|
// printWarn("Skipping invalid image with ID %s", imageResult.ID)
|
|
// }
|
|
// }
|
|
|
|
// Final debug print to show the count of results fetched
|
|
printInfo("Fetched %d image results for overall page %d", len(results), page)
|
|
|
|
return results
|
|
}
|
|
|
|
func wrapImageSearchFunc(f func(string, string, string, int) ([]ImageSearchResult, time.Duration, error)) func(string, string, string, int) ([]SearchResult, time.Duration, error) {
|
|
return func(query, safe, lang string, page int) ([]SearchResult, time.Duration, error) {
|
|
imageResults, duration, err := f(query, safe, lang, page)
|
|
if err != nil {
|
|
return nil, duration, err
|
|
}
|
|
searchResults := make([]SearchResult, len(imageResults))
|
|
for i, result := range imageResults {
|
|
searchResults[i] = result
|
|
}
|
|
return searchResults, duration, nil
|
|
}
|
|
}
|