def __get_full_name(args: dict) -> str:
fullname = args['<package>']
if fullname is None or '/' not in fullname:
warning(
'Incorrect package parameter. Should be namespace/package_name.')
raise ValueError('Incorrect package parameter\'s value')
return fullname
def get_versions(self, fullname: str) -> list:
for cache in self.remote_caches.values():
versions = cache.get_versions(fullname)
if versions:
return versions
warning('No such package ' + fullname)
return []
def check_output(self):
source_files = self.__get_source_files()
output = self.__get_compiled_files()
for source in source_files:
if source not in output:
warning('ErlangMK: ' + source + ' file was not compiled')
return False
return True
def fetch_version(self, fullname: str, vsn: str) -> bool:
for cache in self.remote_caches.values():
maybe_package = cache.fetch_version(fullname, vsn)
if maybe_package:
self.add_fetched(cache, maybe_package)
return True
warning('No such package ' + fullname + ':' + vsn)
return False
def parse_deps(deps: list, content: dict) -> dict:
found = {}
for dep in deps:
depname = 'dep_' + dep
if depname in content:
url, branch = get_dep(content[depname])
found[dep] = Dep(url, branch)
else:
warning('Dep ' + depname + ' not specified')
return found
def compile(self, override_config: ConfigFile or None = None) -> bool:
if self.retry == 0:
return False
if super().compile(override_config):
if not self.check_output(): # compilation was success but some files were not compiled
warning('Retry compilation for ' + self.project_name)
self._retry -= 1
run_cmd(['make', 'clean'], self.project_name, self.root_path, output=None)
return self.compile(override_config=override_config)
return True
return False
def __compare_and_select(self, dep: Package) -> list:
pkg_vsn = self.packages[dep.name].git_vsn
additional_deps = []
if dep.git_vsn != pkg_vsn: # It is not the same dep
try: # try to compare versions
additional_deps = self.__compare_vsns(dep, pkg_vsn)
except ValueError: # not m.m.b version (may be tag vs branch). Just replace.
warning('Skip ' + dep.name + ' (' + dep.git_vsn + '). Use ' +
pkg_vsn)
dep.update_from_duplicate(self.packages[dep.name])
return additional_deps
def _get_versions(self, fullname, ref=None) -> [dict]:
url = join(self.path, 'versions')
data = {'full_name': fullname}
if ref is not None:
data['versions'] = {'ref': ref}
r = post_redirect(url, data, {'Content-type': 'application/json'})
json = r.json()
if json['result'] is not True:
warning('Error accessing ' + url + ': ' + json['response'])
return []
return json['response']
def __fetch_all_deps(self, cache: Cache, package: Package):
for dep in package.deps:
if not self.local_cache.exists(dep):
if cache.exists(dep):
cache.fetch_package(dep)
self.add_fetched(cache, dep)
self.__fetch_all_deps(cache, dep)
else:
warning('Dep ' + dep.name + ' not found in ' + cache.name)
self.__obtain_missing_dep(cache, dep)
self.__fetch_all_deps(cache, dep)
def exists_remote(self, cache: Cache, dep: Package) -> bool:
try:
cache.fetch_package(dep)
self.add_fetched(cache, dep)
self.__fetch_all_deps(cache, dep)
return True
except RemoteCacheException as e:
warning(cache.name + ': {0}'.format(e))
return False
except Exception as e:
warning('Error from remote cache ' + cache.name + ': {0}'.format(e))
return False
def __obtain_missing_dep(self, not_found_cache: Cache, dep: Package):
other_remote = self.remote_caches
for cache in other_remote.values(): # try to find dep in other remotes
if cache is not not_found_cache:
if cache.exists(dep):
warning('Took dep ' + dep.name + ' from ' + cache.name)
cache.fetch_package(dep)
self.add_fetched(cache, dep)
return True
warning('Should fetch and build missing dep ' + dep.name)
self.local_cache.fetch_package(dep)
return self.local_cache.add_package(dep)
def get_erlang_version(default_erlang=None):
try:
vsn = subprocess.check_output(
shlex.split(
"erl -eval 'erlang:display(erlang:system_info(otp_release)), halt().' -noshell"
))
# Try to figure out vsn via cat as when called from Erlang it fails to get version via erl
except subprocess.CalledProcessError:
with open('/usr/lib/erlang/releases/RELEASES', 'r') as rel:
file = rel.read()
return file.split(',')[2].strip('"')
except FileNotFoundError:
warning('No erlang installed!')
return default_erlang
return vsn.decode('utf-8').strip("\n\r\"")
def uninstall(self, fullname: str) -> bool:
packages = self.__search_by_name(fullname)
if not packages:
warning(fullname + ' not installed')
return False
for package in packages:
vsn = package['vsn']
erlang_vsns = self.local_cache.get_erl_versions(fullname, package['vsn'])
[latest_erl] = erlang_vsns[-1:]
pack = Package.from_path(join(self.local_cache.path, fullname, vsn, latest_erl))
if not pack.uninstall():
warning('Can\'t uninstall package ' + fullname + ': ' + vsn)
return False
info(fullname + ': ' + vsn + ' uninstalled')
self.__remove_from_installed(fullname, vsn)
return True
def install(self, fullname: str, maybe_version: str or None) -> bool:
vsn = self.get_package_version(fullname, maybe_version)
if not self.system_config.cache.check_exists_local(fullname, vsn):
if not self.fetch(fullname, vsn):
warning('No ' + fullname + ':' + vsn + ' in local cache. Can\'t fetch it either.')
info('Available versions for ' + fullname + ': ' + str(self.local_cache.get_versions(fullname)))
return False
erlang_vsns = self.local_cache.get_erl_versions(fullname, vsn)
[latest_erl] = erlang_vsns[-1:]
# populate and build deps
builder = Builder.init_from_path(join(self.local_cache.path, fullname, vsn, latest_erl))
builder.populate()
builder.deps()
if builder.project.install(self.system_config, latest_erl):
self.__add_to_installed(fullname, vsn)
info(fullname + ': ' + vsn + ' installed')
return True
return False
