예제 #1
0
    def _reverse_geocode_nominatim(self, coordinates):
        """Reverse geocoding using the Nominatim API.

        Reverse geocoding tries to convert geographic coordinates
        to an accurate address.

        :param coordinates: input coordinates
        :type coordinates: Coordinates
        :return: an address or None if no address was found
        :rtype: GeocodingResult or None
        """
        url = "%s&addressdetails=1&lat=%f&lon=%f" % (self.NOMINATIM_API_URL,
                                                     coordinates.latitude,
                                                     coordinates.longitude)
        try:
            reply = requests_session().get(
                url, timeout=constants.NETWORK_CONNECTION_TIMEOUT, verify=True)
            if reply.status_code == requests.codes.ok:
                reply_dict = reply.json()
                territory_code = reply_dict['address']['country_code'].upper()
                return GeocodingResult(coordinates=coordinates,
                                       territory_code=territory_code)
            else:
                log.error(
                    "Geoloc: Nominatim reverse geocoding failed with status code: %s",
                    reply.status_code)
                return None
        except requests.exceptions.RequestException as e:
            log.debug(
                "Geoloc: RequestException during Nominatim reverse geocoding:\n%s",
                e)
        except ValueError as e:
            log.debug(
                "Geoloc: Unable to decode Nominatim reverse geocoding JSON:\n%s",
                e)
예제 #2
0
    def _reverse_geocode_nominatim(self, coordinates):
        """Reverse geocoding using the Nominatim API
        Reverse geocoding tries to convert geographic coordinates
        to an accurate address.

        :param coordinates: input coordinates
        :type coordinates: Coordinates
        :return: an address or None if no address was found
        :rtype: GeocodingResult or None
        """
        url = "%s&addressdetails=1&lat=%f&lon=%f" % (
            self.NOMINATIM_API_URL,
            coordinates.latitude,
            coordinates.longitude)
        try:
            reply = requests_session().get(url, timeout=constants.NETWORK_CONNECTION_TIMEOUT, verify=True)
            if reply.status_code == requests.codes.ok:
                reply_dict = reply.json()
                territory_code = reply_dict['address']['country_code'].upper()
                return GeocodingResult(coordinates=coordinates,
                                       territory_code=territory_code)
            else:
                log.error("Geoloc: Nominatim reverse geocoding failed with status code: %s", reply.status_code)
                return None
        except requests.exceptions.RequestException as e:
            log.debug("Geoloc: RequestException during Nominatim reverse geocoding:\n%s", e)
        except ValueError as e:
            log.debug("Geoloc: Unable to decode Nominatim reverse geocoding JSON:\n%s", e)
예제 #3
0
    def _download_repoMD(self, method):
        proxies = {}
        repomd = ""
        headers = {"user-agent": USER_AGENT}
        sslverify = not flags.noverifyssl

        if hasattr(method, "proxy"):
            proxy_url = method.proxy
            try:
                proxy = ProxyString(proxy_url)
                proxies = {"http": proxy.url,
                           "https": proxy.url}
            except ProxyStringError as e:
                log.info("Failed to parse proxy for test if repo available %s: %s",
                         proxy_url, e)

        session = requests_session()

        # Test all urls for this repo. If any of these is working it is enough.
        for url in self._urls:
            try:
                result = session.get("%s/repodata/repomd.xml" % url, headers=headers,
                                     proxies=proxies, verify=sslverify)
                if result.ok:
                    repomd = result.text
                    break
                else:
                    log.debug("Server returned %i code when downloading repomd", result.status_code)
                    continue
            except RequestException as e:
                log.debug("Can't download new repomd.xml from %s with proxy: %s. Error: %s", url, proxies, e)

        return repomd
예제 #4
0
    def __init__(self, data):
        """ data is a kickstart.AnacondaKSHandler class
        """
        if self.__class__ is Payload:
            raise TypeError("Payload is an abstract class")

        self.data = data
        self.storage = None
        self.instclass = None
        self.txID = None

        self._session = requests_session()
예제 #5
0
    def __init__(self, data):
        """ data is a kickstart.AnacondaKSHandler class
        """
        if self.__class__ is Payload:
            raise TypeError("Payload is an abstract class")

        self.data = data
        self.storage = None
        self.instclass = None
        self.txID = None

        self._session = requests_session()
예제 #6
0
    def __init__(self, data):
        """ data is a kickstart.AnacondaKSHandler class
        """
        if self.__class__ is Payload:
            raise TypeError("Payload is an abstract class")

        self.data = data
        self.storage = None
        self.instclass = None
        self.txID = None

        # A list of verbose error strings from the subclass
        self.verbose_errors = []

        self._session = requests_session()
예제 #7
0
    def __init__(self, data):
        """ data is a kickstart.AnacondaKSHandler class
        """
        if self.__class__ is Payload:
            raise TypeError("Payload is an abstract class")

        self.data = data
        self.storage = None
        self.instclass = None
        self.txID = None

        # A list of verbose error strings from the subclass
        self.verbose_errors = []

        self._session = requests_session()
예제 #8
0
    def _download_repoMD(self, method):
        proxies = {}
        repomd = ""
        headers = {"user-agent": USER_AGENT}
        sslverify = not flags.noverifyssl

        if hasattr(method, "proxy"):
            proxy_url = method.proxy
            try:
                proxy = ProxyString(proxy_url)
                proxies = {"http": proxy.url, "https": proxy.url}
            except ProxyStringError as e:
                log.info(
                    "Failed to parse proxy for test if repo available %s: %s",
                    proxy_url, e)

        session = requests_session()

        # Test all urls for this repo. If any of these is working it is enough.
        for url in self._urls:
            try:
                result = session.get("%s/repodata/repomd.xml" % url,
                                     headers=headers,
                                     proxies=proxies,
                                     verify=sslverify)
                if result.ok:
                    repomd = result.text
                    break
                else:
                    log.debug(
                        "Server returned %i code when downloading repomd",
                        result.status_code)
                    continue
            except RequestException as e:
                log.debug(
                    "Can't download new repomd.xml from %s with proxy: %s. Error: %s",
                    url, proxies, e)

        return repomd
예제 #9
0
 def __init__(self):
     self._result = LocationResult()
     self._result_lock = threading.Lock()
     self._session = requests_session()
     self._refresh_condition = threading.Condition()
     self._refresh_in_progress = False
예제 #10
0
 def __init__(self):
     self._result = None
     self._result_lock = threading.Lock()
     self._session = requests_session()
예제 #11
0
 def __init__(self):
     self._result = None
     self._result_lock = threading.Lock()
     self._session = requests_session()
예제 #12
0
파일: geoloc.py 프로젝트: jaymzh/anaconda
 def __init__(self):
     self._result = LocationResult()
     self._result_lock = threading.Lock()
     self._session = requests_session()
     self._refresh_condition = threading.Condition()
     self._refresh_in_progress = False