def ensure_remote(self, url):
if self.original_url == self.url:
remote_name = "origin"
else:
remote_name = utils.url_directory_name(url)
command = [
self.ostree,
"remote",
"add",
"--if-not-exists",
"--repo",
self.mirror,
remote_name,
url,
]
if self.gpg_key_path:
command.extend(["--gpg-import", self.gpg_key_path])
else:
command.extend(["--no-gpg-verify"])
self.call(command, fail="Failed to configure origin {}".format(url))
return remote_name
def configure(self, node):
node.validate_keys(
["url", "ref", "track", "gpg-key", *Source.COMMON_CONFIG_KEYS]
)
self.ostree = None
self.original_url = node.get_str("url")
self.url = self.translate_url(self.original_url)
self.ref = node.get_str("ref", None)
self.tracking = node.get_str("track", None)
self.mirror = os.path.join(
self.get_mirror_directory(),
utils.url_directory_name(self.original_url),
)
# At this point we now know if the source has a ref and/or a track.
# If it is missing both then we will be unable to track or build.
if self.ref is None and self.tracking is None:
raise SourceError(
"{}: OSTree sources require a ref and/or track".format(self),
reason="missing-track-and-ref",
)
# (optional) Not all repos are signed. But if they are, get the gpg key
self.gpg_key_path = None
gpg_key_node = node.get_scalar("gpg-key", None)
if not gpg_key_node.is_none():
self.gpg_key = self.node_get_project_path(
gpg_key_node, check_is_file=True
)
self.gpg_key_path = os.path.join(
self.get_project_directory(), self.gpg_key
)
def _get_mirror_dir(self):
return os.path.join(
self.cargo.get_mirror_directory(),
utils.url_directory_name(self.cargo.url),
self.name,
self.version,
)
def configure(self, node):
self.node_validate(node, ['match', 'path', 'url', 'ref', 'gpg'] + Source.COMMON_CONFIG_KEYS)
self.original_url = self.node_get_member(node, str, 'url', None)
if self.original_url:
self.url = self.translate_url(self.original_url)
else:
path = self.node_get_project_path(node, 'path')
fullpath = os.path.join(self.get_project_directory(), path)
self.url = self.original_url = 'file://{}'.format(fullpath)
self.ref = self.node_get_member(node, list, 'ref', None)
if self.ref is not None:
for r in self.ref:
self.node_validate(r, ['ref', 'checksum'])
self.mirror = os.path.join(self.get_mirror_directory(),
utils.url_directory_name(self.original_url))
gpg = self.node_get_project_path(node, 'gpg')
self.gpg = os.path.join(self.get_project_directory(), gpg)
self.match = self.node_get_member(node, str, 'match', None)
self.repo = OSTree.Repo.new(Gio.File.new_for_path(self.mirror))
if os.path.isdir(self.mirror):
self.repo.open()
else:
os.makedirs(self.mirror)
self.repo.create(OSTree.RepoMode.ARCHIVE)
self.repo.remote_add('origin', self.url, None, None)
gpgfile = Gio.File.new_for_path(self.gpg)
self.repo.remote_gpg_import('origin', gpgfile.read(None), None, None)
def _fetch(self, alias_override=None):
url = self.source.translate_url(self.url,
alias_override=alias_override,
primary=self.primary)
mirror = self.mirror_path()
if alias_override:
remote_name = utils.url_directory_name(alias_override)
_, remotes = self.source.check_output(
[self.source.host_git, 'remote'],
fail="Failed to retrieve list of remotes in {}".format(mirror),
cwd=mirror)
if remote_name not in remotes:
self.source.call(
[self.source.host_git, 'remote', 'add', remote_name, url],
fail="Failed to add remote {} with url {}".format(
remote_name, url),
cwd=mirror)
else:
remote_name = "origin"
self.source.call(
[
self.source.host_git, 'fetch', remote_name, '--prune',
'--tags', '--force'
],
fail="Failed to fetch from remote git repository: {}".format(url),
fail_temporarily=True,
cwd=self.mirror)
def _mirror(self):
if not self.ref:
return None
return os.path.join(
self.get_mirror_directory(),
utils.url_directory_name(self.original_url),
hashlib.sha256(self.ref.encode()).hexdigest(),
)
def configure(self, node):
self.original_url = node.get_str("url")
self.ref = node.get_str("ref", None)
self.url = self.translate_url(self.original_url)
self._mirror_dir = os.path.join(
self.get_mirror_directory(),
utils.url_directory_name(self.original_url),
)
self._warn_deprecated_etag(node)
def set_ref(self, ref):
self.ref = ref
if ref is None:
self.fetch_mirror = None
else:
ref_dirname = utils.url_directory_name('{}#{}'.format(
self.url, ref))
self.fetch_mirror = os.path.join(
self.source.get_mirror_directory(), ref_dirname)
def __init__(self, source, path, url, ref, *, primary=False, tags=None):
super().__init__()
self.source = source
self.path = path
self.url = url
self.ref = ref
self.tags = tags or []
self.primary = primary
self.mirror = os.path.join(source.get_mirror_directory(),
utils.url_directory_name(url))
def _locked(self):
lockdir = os.path.join(self.get_mirror_directory(), "locks")
lockfile = os.path.join(
lockdir,
utils.url_directory_name(self.original_url) + ".lock")
os.makedirs(lockdir, exist_ok=True)
with open(lockfile, "w") as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
try:
yield
finally:
fcntl.flock(lock, fcntl.LOCK_UN)
def __init__(self,
source,
path,
url,
ref,
*,
primary=False,
full_clone=False):
super().__init__()
self.source = source
self.path = path
self.url = url
self.primary = primary
self.mirror = os.path.join(source.get_mirror_directory(),
utils.url_directory_name(url))
self.mark_download_url(url)
self.full_clone = full_clone
self.set_ref(ref)
def _get_mirror_dir(self):
return os.path.join(self.get_mirror_directory(),
utils.url_directory_name(self.original_url))
def dirpath(url, aliases):
dirname = url_directory_name(resolve_url(url, aliases))
return os.path.join(sourcedir, kind, dirname)