def tagged_release_url(self, version):
token = self._os_token
url = self._mozila_release_tag.format(version)
if token:
console("GH_TOKEN will be used to perform requests")
return url + "?access_token={0}".format(token)
return url
def latest_release_url(self):
token = self._os_token
url = self._latest_release_url
if token:
console("GH_TOKEN will be used to perform requests")
return "{base_url}?access_token={access_token}".format(
base_url=url, access_token=token)
return url
def __unpack(self, path, to_directory=None):
console("Unpack archive {}".format(path))
if not to_directory:
to_directory = os.path.dirname(path)
if path.endswith(".zip"):
return extract_zip(path, to_directory)
else:
file_list = extract_tar_file(path, to_directory)
return [x.name for x in file_list]
def unpack(archive, to_directory=None):
console("Unpack archive {}".format(archive.name))
if not to_directory:
to_directory = os.path.dirname(archive.name)
if archive.name.endswith(".zip"):
return extract_zip(archive, to_directory)
else:
file_list = extract_tar_file(archive, to_directory)
return [x.name for x in file_list]
def __init__(self, name, version, os_type, url, latest_release_url,
mozila_release_tag):
super(GeckoDriver, self).__init__(name, version, os_type, url,
latest_release_url)
self._mozila_release_tag = mozila_release_tag
self._os_token = os.getenv("GH_TOKEN", None)
self.auth_header = None
if self._os_token:
console("GH_TOKEN will be used to perform requests")
self.auth_header = {'Authorization': f'token {self._os_token}'}
def get_url(self, version):
# type: () -> str
# https://github.com/operasoftware/operachromiumdriver/releases/download/v.2.45/operadriver_linux64.zip
console("Getting latest opera release info for {0}".format(version))
resp = requests.get(self.tagged_release_url(version))
validate_response(resp)
assets = resp.json()["assets"]
name = "{0}_{1}".format(self.get_name(), self.get_os_type())
output_dict = [
asset for asset in assets if asset['name'].startswith(name)
]
return output_dict[0]['browser_download_url']
def __find_file(self, paths, name, version, os_type):
console("\nLooking for [{} {} {}] driver in cache ".format(name, version, os_type))
if len(name) == 0 or len(version) == 0:
return None
if "win" in os_type:
name += ".exe"
for path in paths:
if os.path.isfile(path) and path.endswith(name):
console("File found in cache by path [{}]".format(path))
return path
return None
def get_url(self, version):
# https://github.com/mozilla/geckodriver/releases/download/v0.11.1/geckodriver-v0.11.1-linux64.tar.gz
console("Getting latest mozilla release info for {0}".format(version))
resp = requests.get(self.tagged_release_url(version))
validate_response(resp)
assets = resp.json()["assets"]
name = "{0}-{1}-{2}".format(self.get_name(), version,
self.get_os_type())
output_dict = [
asset for asset in assets if asset['name'].startswith(name)
]
return output_dict[0]['browser_download_url']
def __init__(self,
name,
version,
os_type,
url,
latest_release_url,
opera_release_tag,
DEBUG_LOGGING=True):
super(OperaDriver, self).__init__(name, version, os_type, url,
latest_release_url)
self.opera_release_tag = opera_release_tag
self._os_token = os.getenv("GH_TOKEN", None)
self.auth_header = None
self.DEBUG_LOGGING = DEBUG_LOGGING
if self._os_token:
console("GH_TOKEN will be used to perform requests",
DEBUG_LOGGING=self.DEBUG_LOGGING)
self.auth_header = {'Authorization': f'token {self._os_token}'}
def _download_file(self, driver, path=None):
# type: (Driver) -> file
url = driver.get_url()
console("Trying to download new driver from {}".format(url))
response = requests.get(url, stream=True)
if response.status_code == 404:
raise ValueError(
"There is no such driver {0} with version {1} by {2}".format(
driver.name, driver.get_version(), driver.get_url()))
filename = self._get_filename_from_response(response, driver)
if '"' in filename:
filename = filename.replace('"', "")
if path is None:
driver_path = self._get_driver_path(driver.name,
driver.get_version(),
driver.os_type)
else:
driver_path = path
self.create_cache_dir(driver_path)
file_path = os.path.join(driver_path, filename)
return self._save_file_to_cache(response, file_path)
def get_cached_binary(self, driver):
cached_driver = driver.config.driver_path
is_offline = driver.config.offline
if cached_driver and is_offline == 'True':
console("Using driver from cache {}".format(cached_driver))
return Binary(cached_driver)
name = driver.name
version = driver.get_version()
os_type = driver.os_type
console("")
console("Checking for {} {}:{} in cache".format(
os_type, name, version),
bold=True)
if "win" in os_type:
name += ".exe"
for dirName, subdirList, fileList in os.walk(self.get_cache_path()):
for fname in fileList:
if os.path.join(dirName,
fname).endswith(os.path.join(version, name)):
console("Driver found in {}/{}".format(dirName, fname))
return Binary(os.path.join(dirName, fname))
console("There is no cached driver. Downloading new one...")
return None
def get_cached_binary(self, driver, path=None, subpath=None):
if path is not None:
self.root_dir = path
cached_driver = driver.config.driver_path
is_offline = driver.config.offline
if cached_driver and is_offline == 'True':
console("Using driver from cache {}".format(cached_driver))
return Binary(cached_driver)
name = driver.name
version = driver.get_version()
os_type = driver.os_type
console("")
console("Checking for {} {}:{} in cache".format(
os_type, name, version),
bold=True)
if subpath is not None:
name = subpath
elif "win" in os_type:
name += ".exe"
if path is None:
for dirName, subdirList, fileList in \
os.walk(self.get_cache_path()):
for fname in fileList:
target_file = os.path.join(version, os_type, name)
driver_file = os.path.join(dirName, fname)
if driver_file.endswith(target_file):
console("Driver found in {}/{}".format(dirName, fname))
return Binary(os.path.join(dirName, fname))
else:
if os.path.isfile(os.path.join(path, name)):
console("Driver found in {}".format(os.path.join(path, name)))
return Binary(os.path.join(path, name))
console("There is no cached driver. Downloading new one...")
return None
