def case_insensitive_test(self):
root_folder2 = "sdl/1.5/lasote/stable"
conan_ref2 = ConanFileReference.loads("sdl/1.5@lasote/stable")
os.makedirs("%s/%s" % (root_folder2, EXPORT_FOLDER))
root_folder3 = "assimp/0.14/phil/testing"
conan_ref3 = ConanFileReference.loads("assimp/0.14@phil/testing")
os.makedirs("%s/%s" % (root_folder3, EXPORT_FOLDER))
root_folder4 = "sdl/2.10/lasote/stable"
conan_ref4 = ConanFileReference.loads("sdl/2.10@lasote/stable")
os.makedirs("%s/%s" % (root_folder4, EXPORT_FOLDER))
root_folder5 = "SDL_fake/1.10/lasote/testing"
conan_ref5 = ConanFileReference.loads("SDL_fake/1.10@lasote/testing")
os.makedirs("%s/%s" % (root_folder5, EXPORT_FOLDER))
# Case insensitive searches
search_manager = DiskSearchManager(self.paths)
reg_conans = sorted([str(_reg) for _reg in search_manager.search_recipes("*")])
self.assertEqual(reg_conans, [str(conan_ref5),
str(conan_ref3),
str(conan_ref2),
str(conan_ref4)])
reg_conans = sorted([str(_reg) for _reg in search_manager.search_recipes(pattern="sdl*")])
self.assertEqual(reg_conans, [str(conan_ref5), str(conan_ref2), str(conan_ref4)])
# Case sensitive search
self.assertEqual(str(search_manager.search_recipes(pattern="SDL*", ignorecase=False)[0]),
str(conan_ref5))
def remove(self, pattern, remote, 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 and (build_ids is not None or src):
raise ConanException("Remotes don't have 'build' or 'src' folder, just packages")
if remote:
remote = self._registry.remote(remote)
references = self._remote_manager.search_recipes(remote, pattern)
else:
disk_search = DiskSearchManager(self._client_cache)
references = disk_search.search_recipes(pattern)
if not references:
self._user_io.out.warn("No package recipe matches '%s'" % str(pattern))
return
deleted_refs = []
for reference in references:
assert isinstance(reference, ConanFileReference)
package_ids = package_ids_filter
if packages_query or outdated:
# search packages
if remote:
packages = self._remote_manager.search_packages(remote, reference, packages_query)
else:
packages = disk_search.search_packages(reference, packages_query)
if outdated:
if remote:
recipe_hash = self._remote_proxy.get_conan_manifest(reference).summary_hash
else:
recipe_hash = self._client_cache.load_manifest(reference).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"
% str(reference))
continue
if self._ask_permission(reference, src, build_ids, package_ids, force):
deleted_refs.append(reference)
if remote:
self._remote_remove(reference, package_ids, remote)
else:
deleted_refs.append(reference)
self._local_remove(reference, src, build_ids, package_ids)
if not remote:
self._client_cache.delete_empty_dirs(deleted_refs)
def case_insensitive_test(self):
root_folder2 = "sdl/1.5/lasote/stable"
conan_ref2 = ConanFileReference.loads("sdl/1.5@lasote/stable")
os.makedirs("%s/%s" % (root_folder2, EXPORT_FOLDER))
root_folder3 = "assimp/0.14/phil/testing"
conan_ref3 = ConanFileReference.loads("assimp/0.14@phil/testing")
os.makedirs("%s/%s" % (root_folder3, EXPORT_FOLDER))
root_folder4 = "sdl/2.10/lasote/stable"
conan_ref4 = ConanFileReference.loads("sdl/2.10@lasote/stable")
os.makedirs("%s/%s" % (root_folder4, EXPORT_FOLDER))
root_folder5 = "SDL_fake/1.10/lasote/testing"
conan_ref5 = ConanFileReference.loads("SDL_fake/1.10@lasote/testing")
os.makedirs("%s/%s" % (root_folder5, EXPORT_FOLDER))
# Case insensitive searches
search_adapter = DiskSearchAdapter()
search_manager = DiskSearchManager(self.paths, search_adapter)
reg_conans = sorted(
[str(_reg) for _reg in search_manager.search_recipes("*")])
self.assertEqual(reg_conans, [
str(conan_ref5),
str(conan_ref3),
str(conan_ref2),
str(conan_ref4)
])
reg_conans = sorted([
str(_reg) for _reg in search_manager.search_recipes(pattern="sdl*")
])
self.assertEqual(reg_conans,
[str(conan_ref5),
str(conan_ref2),
str(conan_ref4)])
# Case sensitive search
self.assertEqual(
str(
search_manager.search_recipes(pattern="SDL*",
ignorecase=False)[0]),
str(conan_ref5))
def remove(self,
pattern,
remote,
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 and (build_ids is not None or src):
raise ConanException(
"Remotes don't have 'build' or 'src' folder, just packages")
if remote:
remote = self._registry.remote(remote)
references = self._remote_manager.search_recipes(remote, pattern)
else:
disk_search = DiskSearchManager(self._client_cache)
references = disk_search.search_recipes(pattern)
if not references:
self._user_io.out.warn("No package recipe matches '%s'" %
str(pattern))
return
deleted_refs = []
for reference in references:
assert isinstance(reference, ConanFileReference)
package_ids = package_ids_filter
if packages_query or outdated:
# search packages
if remote:
packages = self._remote_manager.search_packages(
remote, reference, packages_query)
else:
packages = disk_search.search_packages(
reference, packages_query)
if outdated:
if remote:
recipe_hash = self._remote_proxy.get_conan_manifest(
reference).summary_hash
else:
recipe_hash = self._client_cache.load_manifest(
reference).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" %
str(reference))
continue
if self._ask_permission(reference, src, build_ids, package_ids,
force):
deleted_refs.append(reference)
if remote:
self._remote_remove(reference, package_ids, remote)
else:
deleted_refs.append(reference)
self._local_remove(reference, src, build_ids, package_ids)
if not remote:
self._client_cache.delete_empty_dirs(deleted_refs)
class CmdUpload(object):
def __init__(self, client_cache, user_io, remote_manager, remote,
recorder):
self._client_cache = client_cache
self._user_io = user_io
self._remote_proxy = ConanProxy(self._client_cache, self._user_io,
remote_manager, remote, recorder)
self._cache_search = DiskSearchManager(self._client_cache)
def upload(self,
conan_reference_or_pattern,
package_id=None,
all_packages=None,
force=False,
confirm=False,
retry=0,
retry_wait=0,
skip_upload=False,
integrity_check=False,
no_overwrite=None):
"""If package_id is provided, conan_reference_or_pattern is a ConanFileReference"""
if package_id and not _is_a_reference(conan_reference_or_pattern):
raise ConanException(
"-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
t1 = time.time()
if package_id: # Upload package
ref = ConanFileReference.loads(conan_reference_or_pattern)
self._check_reference(ref)
self.upload_package(PackageReference(ref, package_id),
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload,
integrity_check=integrity_check,
no_overwrite=no_overwrite)
else: # Upload conans
self._run_upload(conan_reference_or_pattern,
all_packages=all_packages,
force=force,
confirm=confirm,
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload,
integrity_check=integrity_check,
no_overwrite=no_overwrite)
logger.debug("====> Time manager upload: %f" % (time.time() - t1))
def _run_upload(self,
ref_or_pattern,
force=False,
all_packages=False,
confirm=False,
retry=None,
retry_wait=None,
skip_upload=False,
integrity_check=False,
no_overwrite=None):
"""Upload all the recipes matching 'pattern'"""
if _is_a_reference(ref_or_pattern):
ref = ConanFileReference.loads(ref_or_pattern)
export_path = self._client_cache.export(ref)
if not os.path.exists(export_path):
raise NotFoundException(
"There is no local conanfile exported as %s" % str(ref))
references = [
ref,
]
confirm = True
else:
references = self._cache_search.search_recipes(ref_or_pattern)
if not references:
raise NotFoundException("No packages found matching pattern '%s'" %
ref_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:
self._upload(conan_ref, force, all_packages, retry, retry_wait,
skip_upload, integrity_check, no_overwrite)
def _upload(self, conan_ref, force, all_packages, retry, retry_wait,
skip_upload, integrity_check, no_overwrite):
"""Uploads the recipes and binaries identified by conan_ref"""
if not force:
self._check_recipe_date(conan_ref)
self._user_io.out.info("Uploading %s" % str(conan_ref))
self._remote_proxy.upload_recipe(conan_ref, retry, retry_wait,
skip_upload, no_overwrite)
if all_packages:
self._check_reference(conan_ref)
for index, package_id in enumerate(
self._client_cache.conan_packages(conan_ref)):
total = len(self._client_cache.conan_packages(conan_ref))
self.upload_package(PackageReference(conan_ref, package_id),
index + 1, total, retry, retry_wait,
skip_upload, integrity_check, no_overwrite)
def _check_reference(self, conan_reference):
try:
conanfile_path = self._client_cache.conanfile(conan_reference)
conan_file = load_conanfile_class(conanfile_path)
except NotFoundException:
raise NotFoundException(
"There is no local conanfile exported as %s" %
str(conan_reference))
# Can't use build_policy_always here because it's not loaded (only load_class)
if conan_file.build_policy == "always":
raise ConanException("Conanfile has build_policy='always', "
"no packages can be uploaded")
def upload_package(self,
package_ref,
index=1,
total=1,
retry=None,
retry_wait=None,
skip_upload=False,
integrity_check=False,
no_overwrite=None):
"""Uploads the package identified by package_id"""
msg = ("Uploading package %d/%d: %s" %
(index, total, str(package_ref.package_id)))
t1 = time.time()
self._user_io.out.info(msg)
self._remote_proxy.upload_package(package_ref, retry, retry_wait,
skip_upload, integrity_check,
no_overwrite)
logger.debug("====> Time uploader upload_package: %f" %
(time.time() - t1))
def _check_recipe_date(self, conan_ref):
try:
remote_recipe_manifest = self._remote_proxy.get_conan_digest(
conan_ref)
except NotFoundException:
return # First time uploading this package
local_manifest = self._client_cache.load_manifest(conan_ref)
if (remote_recipe_manifest != local_manifest
and remote_recipe_manifest.time > local_manifest.time):
raise ConanException(
"Remote recipe is newer than local recipe: "
"\n Remote date: %s\n Local date: %s" %
(remote_recipe_manifest.time, local_manifest.time))
class SearchTest(unittest.TestCase):
def setUp(self):
folder = temp_folder()
paths = SimplePaths(folder)
self.search_manager = DiskSearchManager(paths)
os.chdir(paths.store)
self.paths = paths
def basic_test2(self):
conan_ref1 = ConanFileReference.loads("opencv/2.4.10@lasote/testing")
root_folder = str(conan_ref1).replace("@", "/")
artifacts = ["a", "b", "c"]
reg1 = "%s/%s" % (root_folder, EXPORT_FOLDER)
os.makedirs(reg1)
for artif_id in artifacts:
build1 = "%s/%s/%s" % (root_folder, BUILD_FOLDER, artif_id)
artif1 = "%s/%s/%s" % (root_folder, PACKAGES_FOLDER, artif_id)
os.makedirs(build1)
info = ConanInfo().loads("[settings]\n[options]")
save(os.path.join(artif1, CONANINFO), info.dumps())
packages = self.search_manager.search_packages(conan_ref1, "")
all_artif = [_artif for _artif in sorted(packages)]
self.assertEqual(all_artif, artifacts)
def pattern_test(self):
refs = ["opencv/2.4.%s@lasote/testing" % ref for ref in ("1", "2", "3")]
refs = [ConanFileReference.loads(ref) for ref in refs]
for ref in refs:
root_folder = str(ref).replace("@", "/")
reg1 = "%s/%s" % (root_folder, EXPORT_FOLDER)
os.makedirs(reg1)
recipes = self.search_manager.search_recipes("opencv/*@lasote/testing")
self.assertEqual(recipes, refs)
def case_insensitive_test(self):
root_folder2 = "sdl/1.5/lasote/stable"
conan_ref2 = ConanFileReference.loads("sdl/1.5@lasote/stable")
os.makedirs("%s/%s" % (root_folder2, EXPORT_FOLDER))
root_folder3 = "assimp/0.14/phil/testing"
conan_ref3 = ConanFileReference.loads("assimp/0.14@phil/testing")
os.makedirs("%s/%s" % (root_folder3, EXPORT_FOLDER))
root_folder4 = "sdl/2.10/lasote/stable"
conan_ref4 = ConanFileReference.loads("sdl/2.10@lasote/stable")
os.makedirs("%s/%s" % (root_folder4, EXPORT_FOLDER))
root_folder5 = "SDL_fake/1.10/lasote/testing"
conan_ref5 = ConanFileReference.loads("SDL_fake/1.10@lasote/testing")
os.makedirs("%s/%s" % (root_folder5, EXPORT_FOLDER))
# Case insensitive searches
search_manager = DiskSearchManager(self.paths)
reg_conans = sorted([str(_reg) for _reg in search_manager.search_recipes("*")])
self.assertEqual(reg_conans, [str(conan_ref5),
str(conan_ref3),
str(conan_ref2),
str(conan_ref4)])
reg_conans = sorted([str(_reg) for _reg in search_manager.search_recipes(pattern="sdl*")])
self.assertEqual(reg_conans, [str(conan_ref5), str(conan_ref2), str(conan_ref4)])
# Case sensitive search
self.assertEqual(str(search_manager.search_recipes(pattern="SDL*", ignorecase=False)[0]),
str(conan_ref5))
class SearchTest(unittest.TestCase):
def setUp(self):
folder = temp_folder()
paths = SimplePaths(folder)
self.search_manager = DiskSearchManager(paths)
os.chdir(paths.store)
self.paths = paths
def basic_test2(self):
conan_ref1 = ConanFileReference.loads("opencv/2.4.10@lasote/testing")
root_folder = str(conan_ref1).replace("@", "/")
artifacts = ["a", "b", "c"]
reg1 = "%s/%s" % (root_folder, EXPORT_FOLDER)
os.makedirs(reg1)
for artif_id in artifacts:
build1 = "%s/%s/%s" % (root_folder, BUILD_FOLDER, artif_id)
artif1 = "%s/%s/%s" % (root_folder, PACKAGES_FOLDER, artif_id)
os.makedirs(build1)
info = ConanInfo().loads("[settings]\n[options]")
save(os.path.join(artif1, CONANINFO), info.dumps())
packages = self.search_manager.search_packages(conan_ref1, "")
all_artif = [_artif for _artif in sorted(packages)]
self.assertEqual(all_artif, artifacts)
def pattern_test(self):
refs = [
"opencv/2.4.%s@lasote/testing" % ref for ref in ("1", "2", "3")
]
refs = [ConanFileReference.loads(ref) for ref in refs]
for ref in refs:
root_folder = str(ref).replace("@", "/")
reg1 = "%s/%s" % (root_folder, EXPORT_FOLDER)
os.makedirs(reg1)
recipes = self.search_manager.search_recipes("opencv/*@lasote/testing")
self.assertEqual(recipes, refs)
def case_insensitive_test(self):
root_folder2 = "sdl/1.5/lasote/stable"
conan_ref2 = ConanFileReference.loads("sdl/1.5@lasote/stable")
os.makedirs("%s/%s" % (root_folder2, EXPORT_FOLDER))
root_folder3 = "assimp/0.14/phil/testing"
conan_ref3 = ConanFileReference.loads("assimp/0.14@phil/testing")
os.makedirs("%s/%s" % (root_folder3, EXPORT_FOLDER))
root_folder4 = "sdl/2.10/lasote/stable"
conan_ref4 = ConanFileReference.loads("sdl/2.10@lasote/stable")
os.makedirs("%s/%s" % (root_folder4, EXPORT_FOLDER))
root_folder5 = "SDL_fake/1.10/lasote/testing"
conan_ref5 = ConanFileReference.loads("SDL_fake/1.10@lasote/testing")
os.makedirs("%s/%s" % (root_folder5, EXPORT_FOLDER))
# Case insensitive searches
search_manager = DiskSearchManager(self.paths)
reg_conans = sorted(
[str(_reg) for _reg in search_manager.search_recipes("*")])
self.assertEqual(reg_conans, [
str(conan_ref5),
str(conan_ref3),
str(conan_ref2),
str(conan_ref4)
])
reg_conans = sorted([
str(_reg) for _reg in search_manager.search_recipes(pattern="sdl*")
])
self.assertEqual(reg_conans,
[str(conan_ref5),
str(conan_ref2),
str(conan_ref4)])
# Case sensitive search
self.assertEqual(
str(
search_manager.search_recipes(pattern="SDL*",
ignorecase=False)[0]),
str(conan_ref5))
class CmdUpload(object):
def __init__(self, client_cache, user_io, remote_manager, registry):
self._client_cache = client_cache
self._user_io = user_io
self._remote_manager = remote_manager
self._registry = registry
self._cache_search = DiskSearchManager(self._client_cache)
def upload(self, recorder, reference_or_pattern, package_id=None, all_packages=None,
force=False, confirm=False, retry=0, retry_wait=0, skip_upload=False,
integrity_check=False, no_overwrite=None, remote_name=None):
"""If package_id is provided, conan_reference_or_pattern is a ConanFileReference"""
if package_id and not _is_a_reference(reference_or_pattern):
raise ConanException("-p parameter only allowed with a valid recipe reference, "
"not with a pattern")
t1 = time.time()
if package_id or _is_a_reference(reference_or_pattern): # Upload package
ref = ConanFileReference.loads(reference_or_pattern)
references = [ref, ]
confirm = True
else:
references = self._cache_search.search_recipes(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 = load_conanfile_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 package_id:
packages_ids = [package_id, ]
else:
packages_ids = []
self._upload(conan_file, conan_ref, force, packages_ids, retry, retry_wait,
skip_upload, integrity_check, no_overwrite, remote_name, recorder)
logger.debug("====> Time manager upload: %f" % (time.time() - t1))
def _upload(self, conan_file, conan_ref, force, packages_ids, retry, retry_wait, skip_upload,
integrity_check, no_overwrite, remote_name, recorder):
"""Uploads the recipes and binaries identified by conan_ref"""
defined_remote = self._registry.get_ref(conan_ref)
if remote_name: # If remote_name is given, use it
upload_remote = self._registry.remote(remote_name)
elif defined_remote: # Else, if the package had defined a remote, use it
upload_remote = defined_remote
else: # Or use the default otherwise
upload_remote = self._registry.default_remote
if not force:
self._check_recipe_date(conan_ref, upload_remote)
self._user_io.out.info("Uploading %s to remote '%s'"
% (str(conan_ref), upload_remote.name))
self._upload_recipe(conan_ref, retry, retry_wait, skip_upload, no_overwrite, upload_remote)
recorder.add_recipe(str(conan_ref), upload_remote.name, upload_remote.url)
if packages_ids:
# Can't use build_policy_always here because it's not loaded (only load_class)
if conan_file.build_policy == "always":
raise ConanException("Conanfile has build_policy='always', "
"no packages can be uploaded")
total = len(packages_ids)
for index, package_id in enumerate(packages_ids):
ret_upload_package = self._upload_package(PackageReference(conan_ref, package_id),
index + 1, total, retry, retry_wait,
skip_upload, integrity_check,
no_overwrite, upload_remote)
if ret_upload_package:
recorder.add_package(str(conan_ref), package_id)
if not defined_remote and not skip_upload:
self._registry.set_ref(conan_ref, upload_remote)
def _upload_recipe(self, conan_reference, retry, retry_wait, skip_upload, no_overwrite, remote):
conan_file_path = self._client_cache.conanfile(conan_reference)
current_remote = self._registry.get_ref(conan_reference)
if remote != current_remote:
conanfile = load_conanfile_class(conan_file_path)
complete_recipe_sources(self._remote_manager, self._client_cache, self._registry,
conanfile, conan_reference)
ignore_deleted_file = None
else:
ignore_deleted_file = EXPORT_SOURCES_TGZ_NAME
result = self._remote_manager.upload_recipe(conan_reference, remote, retry, retry_wait,
ignore_deleted_file=ignore_deleted_file,
skip_upload=skip_upload,
no_overwrite=no_overwrite)
return result
def _upload_package(self, package_ref, index=1, total=1, retry=None, retry_wait=None,
skip_upload=False, integrity_check=False, no_overwrite=None, remote=None):
"""Uploads the package identified by package_id"""
msg = ("Uploading package %d/%d: %s" % (index, total, str(package_ref.package_id)))
t1 = time.time()
self._user_io.out.info(msg)
result = self._remote_manager.upload_package(package_ref, remote, retry, retry_wait,
skip_upload, integrity_check, no_overwrite)
logger.debug("====> Time uploader upload_package: %f" % (time.time() - t1))
return result
def _check_recipe_date(self, conan_ref, remote):
try:
remote_recipe_manifest = self._remote_manager.get_conan_manifest(conan_ref, remote)
except NotFoundException:
return # First time uploading this package
local_manifest = self._client_cache.load_manifest(conan_ref)
if (remote_recipe_manifest != local_manifest and
remote_recipe_manifest.time > local_manifest.time):
raise ConanException("Remote recipe is newer than local recipe: "
"\n Remote date: %s\n Local date: %s" %
(remote_recipe_manifest.time, local_manifest.time))
