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