mirror of
https://github.com/searxng/searxng.git
synced 2024-11-27 13:21:04 +00:00
467 lines
17 KiB
Python
467 lines
17 KiB
Python
'''
|
|
searx is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
searx is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with searx. If not, see < http://www.gnu.org/licenses/ >.
|
|
|
|
(C) 2013- by Adam Tauber, <asciimoo@gmail.com>
|
|
'''
|
|
|
|
import typing
|
|
import gc
|
|
import threading
|
|
from time import time
|
|
from uuid import uuid4
|
|
from _thread import start_new_thread
|
|
|
|
import requests.exceptions
|
|
import searx.poolrequests as requests_lib
|
|
from searx.engines import engines, settings
|
|
from searx.answerers import ask
|
|
from searx.external_bang import get_bang_url
|
|
from searx.utils import gen_useragent
|
|
from searx.results import ResultContainer
|
|
from searx import logger
|
|
from searx.plugins import plugins
|
|
|
|
|
|
logger = logger.getChild('search')
|
|
|
|
max_request_timeout = settings.get('outgoing', {}).get('max_request_timeout' or None)
|
|
if max_request_timeout is None:
|
|
logger.info('max_request_timeout={0}'.format(max_request_timeout))
|
|
else:
|
|
if isinstance(max_request_timeout, float):
|
|
logger.info('max_request_timeout={0} second(s)'.format(max_request_timeout))
|
|
else:
|
|
logger.critical('outgoing.max_request_timeout if defined has to be float')
|
|
from sys import exit
|
|
|
|
exit(1)
|
|
|
|
|
|
class EngineRef:
|
|
|
|
__slots__ = 'name', 'category', 'from_bang'
|
|
|
|
def __init__(self, name: str, category: str, from_bang: bool=False):
|
|
self.name = name
|
|
self.category = category
|
|
self.from_bang = from_bang
|
|
|
|
def __str__(self):
|
|
return "(" + self.name + "," + self.category + "," + str(self.from_bang) + ")"
|
|
|
|
|
|
class SearchQuery:
|
|
"""container for all the search parameters (query, language, etc...)"""
|
|
|
|
__slots__ = 'query', 'engineref_list', 'categories', 'lang', 'safesearch', 'pageno', 'time_range',\
|
|
'timeout_limit', 'external_bang'
|
|
|
|
def __init__(self,
|
|
query: str,
|
|
engineref_list: typing.List[EngineRef],
|
|
categories: typing.List[str],
|
|
lang: str,
|
|
safesearch: int,
|
|
pageno: int,
|
|
time_range: typing.Optional[str],
|
|
timeout_limit: typing.Optional[float]=None,
|
|
external_bang: typing.Optional[str]=None):
|
|
self.query = query
|
|
self.engineref_list = engineref_list
|
|
self.categories = categories
|
|
self.lang = lang
|
|
self.safesearch = safesearch
|
|
self.pageno = pageno
|
|
self.time_range = time_range
|
|
self.timeout_limit = timeout_limit
|
|
self.external_bang = external_bang
|
|
|
|
def __str__(self):
|
|
return self.query + ";" + str(self.engineref_list)
|
|
|
|
|
|
def send_http_request(engine, request_params):
|
|
# create dictionary which contain all
|
|
# informations about the request
|
|
request_args = dict(
|
|
headers=request_params['headers'],
|
|
cookies=request_params['cookies'],
|
|
verify=request_params['verify'],
|
|
auth=request_params['auth']
|
|
)
|
|
|
|
# setting engine based proxies
|
|
if hasattr(engine, 'proxies'):
|
|
request_args['proxies'] = engine.proxies
|
|
|
|
# specific type of request (GET or POST)
|
|
if request_params['method'] == 'GET':
|
|
req = requests_lib.get
|
|
else:
|
|
req = requests_lib.post
|
|
request_args['data'] = request_params['data']
|
|
|
|
# send the request
|
|
return req(request_params['url'], **request_args)
|
|
|
|
|
|
def search_one_http_request(engine, query, request_params):
|
|
# update request parameters dependent on
|
|
# search-engine (contained in engines folder)
|
|
engine.request(query, request_params)
|
|
|
|
# ignoring empty urls
|
|
if request_params['url'] is None:
|
|
return None
|
|
|
|
if not request_params['url']:
|
|
return None
|
|
|
|
# send request
|
|
response = send_http_request(engine, request_params)
|
|
|
|
# parse the response
|
|
response.search_params = request_params
|
|
return engine.response(response)
|
|
|
|
|
|
def search_one_http_request_safe(engine_name, query, request_params, result_container, start_time, timeout_limit):
|
|
# set timeout for all HTTP requests
|
|
requests_lib.set_timeout_for_thread(timeout_limit, start_time=start_time)
|
|
# reset the HTTP total time
|
|
requests_lib.reset_time_for_thread()
|
|
|
|
#
|
|
engine = engines[engine_name]
|
|
|
|
# suppose everything will be alright
|
|
requests_exception = False
|
|
|
|
try:
|
|
# send requests and parse the results
|
|
search_results = search_one_http_request(engine, query, request_params)
|
|
|
|
# check if the engine accepted the request
|
|
if search_results is not None:
|
|
# yes, so add results
|
|
result_container.extend(engine_name, search_results)
|
|
|
|
# update engine time when there is no exception
|
|
engine_time = time() - start_time
|
|
page_load_time = requests_lib.get_time_for_thread()
|
|
result_container.add_timing(engine_name, engine_time, page_load_time)
|
|
with threading.RLock():
|
|
engine.stats['engine_time'] += engine_time
|
|
engine.stats['engine_time_count'] += 1
|
|
# update stats with the total HTTP time
|
|
engine.stats['page_load_time'] += page_load_time
|
|
engine.stats['page_load_count'] += 1
|
|
|
|
except Exception as e:
|
|
# Timing
|
|
engine_time = time() - start_time
|
|
page_load_time = requests_lib.get_time_for_thread()
|
|
result_container.add_timing(engine_name, engine_time, page_load_time)
|
|
|
|
# Record the errors
|
|
with threading.RLock():
|
|
engine.stats['errors'] += 1
|
|
|
|
if (issubclass(e.__class__, requests.exceptions.Timeout)):
|
|
result_container.add_unresponsive_engine(engine_name, 'timeout')
|
|
# requests timeout (connect or read)
|
|
logger.error("engine {0} : HTTP requests timeout"
|
|
"(search duration : {1} s, timeout: {2} s) : {3}"
|
|
.format(engine_name, engine_time, timeout_limit, e.__class__.__name__))
|
|
requests_exception = True
|
|
elif (issubclass(e.__class__, requests.exceptions.RequestException)):
|
|
result_container.add_unresponsive_engine(engine_name, 'request exception')
|
|
# other requests exception
|
|
logger.exception("engine {0} : requests exception"
|
|
"(search duration : {1} s, timeout: {2} s) : {3}"
|
|
.format(engine_name, engine_time, timeout_limit, e))
|
|
requests_exception = True
|
|
else:
|
|
result_container.add_unresponsive_engine(engine_name, 'unexpected crash', str(e))
|
|
# others errors
|
|
logger.exception('engine {0} : exception : {1}'.format(engine_name, e))
|
|
|
|
# suspend or not the engine if there are HTTP errors
|
|
with threading.RLock():
|
|
if requests_exception:
|
|
# update continuous_errors / suspend_end_time
|
|
engine.continuous_errors += 1
|
|
engine.suspend_end_time = time() + min(settings['search']['max_ban_time_on_fail'],
|
|
engine.continuous_errors * settings['search']['ban_time_on_fail'])
|
|
else:
|
|
# no HTTP error (perhaps an engine error)
|
|
# anyway, reset the suspend variables
|
|
engine.continuous_errors = 0
|
|
engine.suspend_end_time = 0
|
|
|
|
|
|
def record_offline_engine_stats_on_error(engine, result_container, start_time):
|
|
engine_time = time() - start_time
|
|
result_container.add_timing(engine.name, engine_time, engine_time)
|
|
|
|
with threading.RLock():
|
|
engine.stats['errors'] += 1
|
|
|
|
|
|
def search_one_offline_request(engine, query, request_params):
|
|
return engine.search(query, request_params)
|
|
|
|
|
|
def search_one_offline_request_safe(engine_name, query, request_params, result_container, start_time, timeout_limit):
|
|
engine = engines[engine_name]
|
|
|
|
try:
|
|
search_results = search_one_offline_request(engine, query, request_params)
|
|
|
|
if search_results:
|
|
result_container.extend(engine_name, search_results)
|
|
|
|
engine_time = time() - start_time
|
|
result_container.add_timing(engine_name, engine_time, engine_time)
|
|
with threading.RLock():
|
|
engine.stats['engine_time'] += engine_time
|
|
engine.stats['engine_time_count'] += 1
|
|
|
|
except ValueError as e:
|
|
record_offline_engine_stats_on_error(engine, result_container, start_time)
|
|
logger.exception('engine {0} : invalid input : {1}'.format(engine_name, e))
|
|
except Exception as e:
|
|
record_offline_engine_stats_on_error(engine, result_container, start_time)
|
|
result_container.add_unresponsive_engine(engine_name, 'unexpected crash', str(e))
|
|
logger.exception('engine {0} : exception : {1}'.format(engine_name, e))
|
|
|
|
|
|
def search_one_request_safe(engine_name, query, request_params, result_container, start_time, timeout_limit):
|
|
if engines[engine_name].offline:
|
|
return search_one_offline_request_safe(engine_name, query, request_params, result_container, start_time, timeout_limit) # noqa
|
|
return search_one_http_request_safe(engine_name, query, request_params, result_container, start_time, timeout_limit)
|
|
|
|
|
|
def search_multiple_requests(requests, result_container, start_time, timeout_limit):
|
|
search_id = uuid4().__str__()
|
|
|
|
for engine_name, query, request_params in requests:
|
|
th = threading.Thread(
|
|
target=search_one_request_safe,
|
|
args=(engine_name, query, request_params, result_container, start_time, timeout_limit),
|
|
name=search_id,
|
|
)
|
|
th._engine_name = engine_name
|
|
th.start()
|
|
|
|
for th in threading.enumerate():
|
|
if th.name == search_id:
|
|
remaining_time = max(0.0, timeout_limit - (time() - start_time))
|
|
th.join(remaining_time)
|
|
if th.is_alive():
|
|
result_container.add_unresponsive_engine(th._engine_name, 'timeout')
|
|
logger.warning('engine timeout: {0}'.format(th._engine_name))
|
|
|
|
|
|
# get default reqest parameter
|
|
def default_request_params():
|
|
return {
|
|
'method': 'GET',
|
|
'headers': {},
|
|
'data': {},
|
|
'url': '',
|
|
'cookies': {},
|
|
'verify': True,
|
|
'auth': None
|
|
}
|
|
|
|
|
|
class Search:
|
|
"""Search information container"""
|
|
|
|
__slots__ = "search_query", "result_container", "start_time", "actual_timeout"
|
|
|
|
def __init__(self, search_query):
|
|
# init vars
|
|
super().__init__()
|
|
self.search_query = search_query
|
|
self.result_container = ResultContainer()
|
|
self.start_time = None
|
|
self.actual_timeout = None
|
|
|
|
def search_external_bang(self):
|
|
"""
|
|
Check if there is a external bang.
|
|
If yes, update self.result_container and return True
|
|
"""
|
|
if self.search_query.external_bang:
|
|
self.result_container.redirect_url = get_bang_url(self.search_query)
|
|
|
|
# This means there was a valid bang and the
|
|
# rest of the search does not need to be continued
|
|
if isinstance(self.result_container.redirect_url, str):
|
|
return True
|
|
return False
|
|
|
|
def search_answerers(self):
|
|
"""
|
|
Check if an answer return a result.
|
|
If yes, update self.result_container and return True
|
|
"""
|
|
answerers_results = ask(self.search_query)
|
|
|
|
if answerers_results:
|
|
for results in answerers_results:
|
|
self.result_container.extend('answer', results)
|
|
return True
|
|
return False
|
|
|
|
def _is_accepted(self, engine_name, engine):
|
|
# skip suspended engines
|
|
if engine.suspend_end_time >= time():
|
|
logger.debug('Engine currently suspended: %s', engine_name)
|
|
return False
|
|
|
|
# if paging is not supported, skip
|
|
if self.search_query.pageno > 1 and not engine.paging:
|
|
return False
|
|
|
|
# if time_range is not supported, skip
|
|
if self.search_query.time_range and not engine.time_range_support:
|
|
return False
|
|
|
|
return True
|
|
|
|
def _get_params(self, engineref, user_agent):
|
|
if engineref.name not in engines:
|
|
return None, None
|
|
|
|
engine = engines[engineref.name]
|
|
|
|
if not self._is_accepted(engineref.name, engine):
|
|
return None, None
|
|
|
|
# set default request parameters
|
|
request_params = {}
|
|
if not engine.offline:
|
|
request_params = default_request_params()
|
|
request_params['headers']['User-Agent'] = user_agent
|
|
|
|
if hasattr(engine, 'language') and engine.language:
|
|
request_params['language'] = engine.language
|
|
else:
|
|
request_params['language'] = self.search_query.lang
|
|
|
|
request_params['safesearch'] = self.search_query.safesearch
|
|
request_params['time_range'] = self.search_query.time_range
|
|
|
|
request_params['category'] = engineref.category
|
|
request_params['pageno'] = self.search_query.pageno
|
|
|
|
return request_params, engine.timeout
|
|
|
|
# do search-request
|
|
def _get_requests(self):
|
|
# init vars
|
|
requests = []
|
|
|
|
# set default useragent
|
|
# user_agent = request.headers.get('User-Agent', '')
|
|
user_agent = gen_useragent()
|
|
|
|
# max of all selected engine timeout
|
|
default_timeout = 0
|
|
|
|
# start search-reqest for all selected engines
|
|
for engineref in self.search_query.engineref_list:
|
|
# set default request parameters
|
|
request_params, engine_timeout = self._get_params(engineref, user_agent)
|
|
if request_params is None:
|
|
continue
|
|
|
|
# append request to list
|
|
requests.append((engineref.name, self.search_query.query, request_params))
|
|
|
|
# update default_timeout
|
|
default_timeout = max(default_timeout, engine_timeout)
|
|
|
|
# adjust timeout
|
|
actual_timeout = default_timeout
|
|
query_timeout = self.search_query.timeout_limit
|
|
|
|
if max_request_timeout is None and query_timeout is None:
|
|
# No max, no user query: default_timeout
|
|
pass
|
|
elif max_request_timeout is None and query_timeout is not None:
|
|
# No max, but user query: From user query except if above default
|
|
actual_timeout = min(default_timeout, query_timeout)
|
|
elif max_request_timeout is not None and query_timeout is None:
|
|
# Max, no user query: Default except if above max
|
|
actual_timeout = min(default_timeout, max_request_timeout)
|
|
elif max_request_timeout is not None and query_timeout is not None:
|
|
# Max & user query: From user query except if above max
|
|
actual_timeout = min(query_timeout, max_request_timeout)
|
|
|
|
logger.debug("actual_timeout={0} (default_timeout={1}, ?timeout_limit={2}, max_request_timeout={3})"
|
|
.format(actual_timeout, default_timeout, query_timeout, max_request_timeout))
|
|
|
|
return requests, actual_timeout
|
|
|
|
def search_standard(self):
|
|
"""
|
|
Update self.result_container, self.actual_timeout
|
|
"""
|
|
requests, self.actual_timeout = self._get_requests()
|
|
|
|
# send all search-request
|
|
if requests:
|
|
search_multiple_requests(requests, self.result_container, self.start_time, self.actual_timeout)
|
|
start_new_thread(gc.collect, tuple())
|
|
|
|
# return results, suggestions, answers and infoboxes
|
|
return True
|
|
|
|
# do search-request
|
|
def search(self):
|
|
self.start_time = time()
|
|
|
|
if not self.search_external_bang():
|
|
if not self.search_answerers():
|
|
self.search_standard()
|
|
|
|
return self.result_container
|
|
|
|
|
|
class SearchWithPlugins(Search):
|
|
"""Similar to the Search class but call the plugins."""
|
|
|
|
__slots__ = 'ordered_plugin_list', 'request'
|
|
|
|
def __init__(self, search_query, ordered_plugin_list, request):
|
|
super().__init__(search_query)
|
|
self.ordered_plugin_list = ordered_plugin_list
|
|
self.request = request
|
|
|
|
def search(self):
|
|
if plugins.call(self.ordered_plugin_list, 'pre_search', self.request, self):
|
|
super().search()
|
|
|
|
plugins.call(self.ordered_plugin_list, 'post_search', self.request, self)
|
|
|
|
results = self.result_container.get_ordered_results()
|
|
|
|
for result in results:
|
|
plugins.call(self.ordered_plugin_list, 'on_result', self.request, self, result)
|
|
|
|
return self.result_container
|