def get_recipe_file_list(self, ref, auth_user):
self._authorizer.check_read_conan(auth_user, ref)
try:
file_list = self._server_store.get_recipe_file_list(ref)
except NotFoundException:
raise RecipeNotFoundException(ref)
if not file_list:
raise RecipeNotFoundException(ref, print_rev=True)
# Send speculative metadata (empty) for files (non breaking future changes)
return {"files": {key: {} for key in file_list}}
def download(app, ref, package_ids, remote, recipe, recorder, remotes):
out, remote_manager, cache, loader = app.out, app.remote_manager, app.cache, app.loader
hook_manager = app.hook_manager
assert(isinstance(ref, ConanFileReference))
output = ScopedOutput(str(ref), out)
hook_manager.execute("pre_download", reference=ref, remote=remote)
try:
ref = remote_manager.get_recipe(ref, remote)
except NotFoundException:
raise RecipeNotFoundException(ref)
with cache.package_layout(ref).update_metadata() as metadata:
metadata.recipe.remote = remote.name
conan_file_path = cache.package_layout(ref).conanfile()
conanfile = loader.load_basic(conan_file_path)
# Download the sources too, don't be lazy
complete_recipe_sources(remote_manager, cache, conanfile, ref, remotes)
if not recipe: # Not only the recipe
if not package_ids: # User didn't specify a specific package binary
output.info("Getting the complete package list from '%s'..." % ref.full_str())
packages_props = remote_manager.search_packages(remote, ref, None)
package_ids = list(packages_props.keys())
if not package_ids:
output.warn("No remote binary packages found in remote")
_download_binaries(conanfile, ref, package_ids, cache, remote_manager,
remote, output, recorder)
hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=ref,
remote=remote)
def get_package_revisions(self, pref, auth_user):
self._authorizer.check_read_conan(auth_user, pref.ref)
root = self._server_store.conan_revisions_root(pref.ref.copy_clear_rev())
if not self._server_store.path_exists(root):
raise RecipeNotFoundException(pref.ref, print_rev=True)
ret = self._server_store.get_package_revisions(pref)
return ret
def get_recipe_revisions(self, ref):
url = self.router.recipe_revisions(ref)
tmp = self.get_json(url)["revisions"]
if ref.revision:
for r in tmp:
if r["revision"] == ref.revision:
return [r]
raise RecipeNotFoundException(ref, print_rev=True)
return tmp
def get_recipe_revisions(self, ref):
time.sleep(0.1) # Index appears to not being updated immediately after a remove
url = "{}/{}".format(self._repo_url, self._ref_index(ref))
response = requests.get(url, auth=self._auth)
response.raise_for_status()
the_json = response.json()
if not the_json["revisions"]:
raise RecipeNotFoundException(ref)
tmp = [_RevisionEntry(i["revision"], i["time"]) for i in the_json["revisions"]]
return tmp
def get_recipe_snapshot(self, ref):
"""Gets a dict with file paths and the md5:
{filename: md5}
"""
self._authorizer.check_read_conan(self._auth_user, ref)
latest_ref = self._get_latest_ref(ref)
snap = self._server_store.get_recipe_snapshot(latest_ref)
if not snap:
raise RecipeNotFoundException(latest_ref)
return snap
def get_recipe_revisions(self, ref):
"""Returns a RevisionList"""
if ref.revision:
tmp = RevisionList()
tmp.add_revision(ref.revision)
return tmp.as_list()
rev_file_path = self._recipe_revisions_file(ref)
revs = self._get_revisions_list(rev_file_path).as_list()
if not revs:
raise RecipeNotFoundException(ref, print_rev=True)
return revs
def get_conanfile_download_urls(self, ref, files_subset=None):
"""Gets a dict with filepaths and the urls:
{filename: url}
"""
self._authorizer.check_read_conan(self._auth_user, ref)
latest_ref = self._get_latest_ref(ref)
urls = self._server_store.get_download_conanfile_urls(latest_ref,
files_subset, self._auth_user)
if not urls:
raise RecipeNotFoundException(latest_ref)
return urls
def upload_package_file(self, body, headers, pref, filename, auth_user):
self._authorizer.check_write_conan(auth_user, pref.ref)
# FIXME: Check that reference contains revisions (MANDATORY TO UPLOAD)
# Check if the recipe exists
recipe_path = self._server_store.export(pref.ref)
if not os.path.exists(recipe_path):
raise RecipeNotFoundException(pref.ref)
path = self._server_store.get_package_file_path(pref, filename)
self._upload_to_path(body, headers, path)
# If the upload was ok, update the pointer to the latest
self._server_store.update_last_package_revision(pref)
def get_recipe_manifest_url(name, version, username, channel,
auth_user):
"""
Get a dict with all files and the download url
"""
conan_service = ConanService(app.authorizer, app.server_store,
auth_user)
ref = ConanFileReference(name, version, username, channel)
urls = conan_service.get_conanfile_download_urls(
ref, [CONAN_MANIFEST])
if not urls:
raise RecipeNotFoundException(ref)
return urls
def search_packages(package_layout, query):
""" Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param package_layout: Layout for the given reference
"""
if not os.path.exists(package_layout.base_folder()) or (
package_layout.ref.revision and
package_layout.recipe_revision() != package_layout.ref.revision):
raise RecipeNotFoundException(package_layout.ref, print_rev=True)
infos = _get_local_infos_min(package_layout)
return filter_packages(query, infos)
def get_conanfile_download_urls(name, version, username, channel,
auth_user):
"""
Get a dict with all files and the download url
"""
conan_service = ConanService(app.authorizer, app.server_store,
auth_user)
ref = ConanFileReference(name, version, username, channel)
try:
urls = conan_service.get_conanfile_download_urls(ref)
except NotFoundException:
raise RecipeNotFoundException(ref)
urls_norm = {
filename.replace("\\", "/"): url
for filename, url in urls.items()
}
return urls_norm
def search_packages(server_store, ref, query, look_in_all_rrevs):
"""
Used both for v1 and v2. V1 will iterate rrevs.
Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param ref: ConanFileReference object
"""
if not look_in_all_rrevs and ref.revision is None:
latest_rev = server_store.get_last_revision(ref).revision
ref = ref.copy_with_rev(latest_rev)
if not os.path.exists(server_store.conan_revisions_root(ref.copy_clear_rev())):
raise RecipeNotFoundException(ref)
infos = _get_local_infos_min(server_store, ref, look_in_all_rrevs)
return filter_packages(query, infos)
def remove_conanfile(self, ref):
""" Remove a recipe and packages """
self.check_credentials()
if ref.revision is None:
# Remove all the RREVs
revisions = self.get_recipe_revisions(ref)
refs = [ref.copy_with_rev(rev["revision"]) for rev in revisions]
else:
refs = [ref]
for ref in refs:
url = self.router.remove_recipe(ref)
logger.debug("REST: remove: %s" % url)
response = self.requester.delete(url, auth=self.auth, headers=self.custom_headers,
verify=self.verify_ssl)
if response.status_code == 404:
raise RecipeNotFoundException(ref)
if response.status_code != 200: # Error message is text
# To be able to access ret.text (ret.content are bytes)
response.charset = "utf-8"
raise get_exception_from_error(response.status_code)(response.text)
def load_metadata(self):
try:
text = load(self.package_metadata())
except IOError:
raise RecipeNotFoundException(self._ref)
return PackageMetadata.loads(text)
def remove(self,
pattern,
remote_name,
src=None,
build_ids=None,
package_ids_filter=None,
force=False,
packages_query=None,
outdated=False):
""" Remove local/remote conans, package folders, etc.
@param src: Remove src folder
@param pattern: it could be OpenCV* or OpenCV or a ConanFileReference
@param build_ids: Lists with ids or empty for all. (Its a filter)
@param package_ids_filter: Lists with ids or empty for all. (Its a filter)
@param force: if True, it will be deleted without requesting anything
@param packages_query: Only if src is a reference. Query settings and options
"""
if remote_name and (build_ids is not None or src):
raise ConanException(
"Remotes don't have 'build' or 'src' folder, just packages")
is_reference = check_valid_ref(pattern)
input_ref = ConanFileReference.loads(pattern) if is_reference else None
if not input_ref and packages_query is not None:
raise ConanException(
"query parameter only allowed with a valid recipe "
"reference as the search pattern.")
if input_ref and package_ids_filter and not input_ref.revision:
for package_id in package_ids_filter:
if "#" in package_id:
raise ConanException(
"Specify a recipe revision if you specify a package "
"revision")
if remote_name:
remote = self._remotes[remote_name]
if input_ref:
if not self._cache.config.revisions_enabled and input_ref.revision:
raise ConanException(
"Revisions not enabled in the client, cannot remove "
"revisions in the server")
refs = [input_ref]
else:
refs = self._remote_manager.search_recipes(remote, pattern)
else:
if input_ref:
refs = []
if self._cache.installed_as_editable(input_ref):
raise ConanException(
self._message_removing_editable(input_ref))
if not self._cache.package_layout(input_ref).recipe_exists():
raise RecipeNotFoundException(
input_ref,
print_rev=self._cache.config.revisions_enabled)
refs.append(input_ref)
else:
refs = search_recipes(self._cache, pattern)
if not refs:
self._user_io.out.warn("No package recipe matches '%s'" %
str(pattern))
return
if input_ref and not input_ref.revision:
# Ignore revisions for deleting if the input was not with a revision
# (Removing all the recipe revisions from a reference)
refs = [r.copy_clear_rev() for r in refs]
deleted_refs = []
for ref in refs:
assert isinstance(ref, ConanFileReference)
package_layout = self._cache.package_layout(ref)
package_ids = package_ids_filter
if packages_query or outdated:
# search packages
if remote_name:
packages = self._remote_manager.search_packages(
remote, ref, packages_query)
else:
packages = search_packages(package_layout, packages_query)
if outdated:
if remote_name:
manifest, ref = self._remote_manager.get_recipe_manifest(
ref, remote)
recipe_hash = manifest.summary_hash
else:
recipe_hash = package_layout.recipe_manifest(
).summary_hash
packages = filter_outdated(packages, recipe_hash)
if package_ids_filter:
package_ids = [
p for p in packages if p in package_ids_filter
]
else:
package_ids = list(packages.keys())
if not package_ids:
self._user_io.out.warn(
"No matching packages to remove for %s" %
ref.full_str())
continue
if self._ask_permission(ref, src, build_ids, package_ids, force):
try:
if remote_name:
self._remote_remove(ref, package_ids, remote)
else:
self._local_remove(ref, src, build_ids, package_ids)
except NotFoundException:
# If we didn't specify a pattern but a concrete ref, fail if there is no
# ref to remove
if input_ref:
raise
else:
deleted_refs.append(ref)
if not remote_name:
self._cache.delete_empty_dirs(deleted_refs)
def get_latest_revision(self, ref, auth_user):
self._authorizer.check_read_conan(auth_user, ref)
tmp = self._server_store.get_last_revision(ref)
if not tmp:
raise RecipeNotFoundException(ref, print_rev=True)
return tmp
