def _collects_refs_to_upload(self, package_id, reference_or_pattern,
confirm):
""" validate inputs and compute the refs (without revisions) to be uploaded
"""
if package_id and not check_valid_ref(reference_or_pattern,
strict_mode=False):
raise ConanException(
"-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
if package_id or check_valid_ref(reference_or_pattern):
# Upload package
ref = ConanFileReference.loads(reference_or_pattern)
if ref.revision and not self._cache.config.revisions_enabled:
raise ConanException(
"Revisions not enabled in the client, specify a "
"reference without revision")
refs = [
ref,
]
confirm = True
else:
refs = search_recipes(self._cache, reference_or_pattern)
if not refs:
raise NotFoundException(
("No packages found matching pattern '%s'" %
reference_or_pattern))
return refs, confirm
def test_conanfileref(self):
ref = ConanFileReference.loads("package/1.0@user/channel")
self.assertTrue(check_valid_ref(ref, allow_pattern=False))
self.assertTrue(check_valid_ref(ref, allow_pattern=True))
ref_pattern = ConanFileReference.loads("package/*@user/channel")
self.assertFalse(check_valid_ref(ref_pattern, allow_pattern=False))
self.assertTrue(check_valid_ref(ref_pattern, allow_pattern=True))
def test_string(self):
self.assertTrue(
check_valid_ref("package/1.0@user/channel", allow_pattern=False))
self.assertTrue(
check_valid_ref("package/1.0@user/channel", allow_pattern=True))
self.assertFalse(
check_valid_ref("package/*@user/channel", allow_pattern=False))
self.assertTrue(
check_valid_ref("package/1.0@user/channel", allow_pattern=True))
def _load_data(self, ref, settings, options):
parser = self._parse_layout_file(ref, settings, options)
# Build a convenient data structure
data = OrderedDict()
folders = {}
for section in parser.sections():
reference, section_name = section.rsplit(":", 1) if ':' in section else (None, section)
if section_name in EditableLayout.folders:
items = [k for k, _ in parser.items(section)] or [""]
if len(items) > 1:
raise ConanException("'%s' with more than one value in layout file: %s"
% (section_name, self._filepath))
folders.setdefault(reference, {})[section_name] = self._work_on_item(items[0])
continue
if section_name not in EditableLayout.cpp_info_dirs:
raise ConanException("Wrong cpp_info field '%s' in layout file: %s"
% (section_name, self._filepath))
if reference:
if not check_valid_ref(reference):
raise ConanException("Wrong package reference '%s' in layout file: %s"
% (reference, self._filepath))
else:
r = ConanFileReference.loads(reference, validate=True)
if r.revision:
raise ConanException("Don't provide revision in Editable layouts")
data.setdefault(reference, {})[section_name] =\
[self._work_on_item(k) for k, _ in parser.items(section)]
return data, folders
def test_only_user_channel(self):
tmp = get_reference_fields("user/channel", user_channel_input=True)
self.assertEqual(tmp, (None, None, "user", "channel", None))
tmp = get_reference_fields("user", user_channel_input=True)
self.assertEqual(tmp, (None, None, "user", None, None))
tmp = get_reference_fields("/channel", user_channel_input=True)
self.assertEqual(tmp, (None, None, None, "channel", None))
ref_pattern = ConanFileReference.loads("package/*@user/channel")
self.assertFalse(check_valid_ref(ref_pattern, strict_mode=False))
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 upload(self,
recorder,
reference_or_pattern,
package_id=None,
all_packages=None,
confirm=False,
retry=0,
retry_wait=0,
integrity_check=False,
policy=None,
remote_name=None,
query=None):
"""If package_id is provided, conan_reference_or_pattern is a ConanFileReference"""
if package_id and not check_valid_ref(reference_or_pattern,
allow_pattern=False):
raise ConanException(
"-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
t1 = time.time()
if package_id or check_valid_ref(reference_or_pattern,
allow_pattern=False):
# Upload package
ref = ConanFileReference.loads(reference_or_pattern)
references = [
ref,
]
confirm = True
else:
references = search_recipes(self._client_cache,
reference_or_pattern)
if not references:
raise NotFoundException(
("No packages found matching pattern '%s'" %
reference_or_pattern))
for conan_ref in references:
upload = True
if not confirm:
msg = "Are you sure you want to upload '%s'?" % str(conan_ref)
upload = self._user_io.request_boolean(msg)
if upload:
try:
conanfile_path = self._client_cache.conanfile(conan_ref)
conan_file = self._loader.load_class(conanfile_path)
except NotFoundException:
raise NotFoundException(
("There is no local conanfile exported as %s" %
str(conan_ref)))
if all_packages:
packages_ids = self._client_cache.conan_packages(conan_ref)
elif query:
packages = search_packages(self._client_cache, conan_ref,
query)
packages_ids = list(packages.keys())
elif package_id:
packages_ids = [
package_id,
]
else:
packages_ids = []
self._upload(conan_file, conan_ref, packages_ids, retry,
retry_wait, integrity_check, policy, remote_name,
recorder)
logger.debug("UPLOAD: Time manager upload: %f" % (time.time() - t1))
def test_incomplete_refs(self):
self.assertTrue(check_valid_ref("package/1.0", strict_mode=False))
self.assertFalse(check_valid_ref("package/1.0"))
self.assertFalse(check_valid_ref("package/1.0@user"))
self.assertFalse(check_valid_ref("package/1.0@/channel"))
self.assertFalse(check_valid_ref("lib@#rev"))
def test_string(self):
self.assertTrue(check_valid_ref("package/1.0@user/channel"))
self.assertTrue(check_valid_ref("package/1.0@user/channel"))
def test_string(self):
self.assertTrue(check_valid_ref("package/1.0@user/channel"))
self.assertTrue(check_valid_ref("package/1.0@user/channel"))
self.assertTrue(check_valid_ref("package/[*]@user/channel"))
self.assertTrue(check_valid_ref("package/[>1.0]@user/channel"))
self.assertTrue(check_valid_ref("package/[1.*]@user/channel"))
# Patterns are invalid
self.assertFalse(check_valid_ref("package/*@user/channel"))
self.assertFalse(check_valid_ref("package/1.0@user/*"))
self.assertFalse(check_valid_ref("package/1.0@user/chan*"))
self.assertFalse(check_valid_ref("package/[>1.0]@user/chan*"))
self.assertFalse(check_valid_ref("*/1.0@user/channel"))
self.assertFalse(check_valid_ref("package*/1.0@user/channel"))
# * pattern is valid in non stric_mode
self.assertTrue(
check_valid_ref("package/*@user/channel", strict_mode=False))
self.assertTrue(check_valid_ref("package/*@user/*", strict_mode=False))
# But other patterns are not valid in non stric_mode
self.assertFalse(
check_valid_ref("package/1.0@user/chan*", strict_mode=False))
