def install(args):
"""Install the given requirements without linking them into an environment.
This is a low-level command, and is generally unused.
Examples:
# Install a single package.
vee install [email protected]:westernx/sgmock
# Install multiple packages.
vee install [email protected]:westernx/sgmock [email protected]:westernx/sgsession \\
http:/example.org/path/to/tarball.tgz --make-install
# Install from a requirement set.
vee install path/to/requirements.txt
"""
home = args.assert_home()
if not args.requirements:
raise ValueError('please provide requirements to install')
reqs = Requirements(args.requirements, home=home)
pkgs = PackageSet(home=home)
# TODO: Resolve everything at once like upgrade does.
for req in reqs.iter_packages():
pkg = pkgs.resolve(req, check_existing=not args.force)
try:
pkgs.install(pkg.name, reinstall=args.force)
except AlreadyInstalled:
print style('Already installed', 'blue', bold=True), style(str(pkg.freeze()), bold=True)
def upgrade(self,
dirty=False,
subset=None,
reinstall=False,
relink=False,
no_deps=False,
force_branch_link=True):
self.clone_if_not_exists()
try:
head = self.head
except CalledProcessError:
log.warning(style_warning('no commits in repository'))
head = None
try:
remote_head = self.rev_parse('%s/%s' %
(self.remote_name, self.branch_name))
except ValueError:
log.warning(
style_warning('tracked %s/%s does not exist in self' %
(self.remote_name, self.branch_name)))
remote_head = None
if remote_head and head != remote_head:
log.warning(
style_warning('%s repo not checked out to %s/%s' %
(self.name, self.remote_name, self.branch_name)))
dirty = bool(list(self.status()))
if not dirty and self.is_dirty():
log.error('%s repo is dirty; force with --dirty' % self.name)
return False
env = self.get_environment()
req_set = self.load_requirements()
pkg_set = PackageSet(env=env, home=self.home)
# Register the whole set, so that dependencies are pulled from here instead
# of weakly resolved from installed packages.
# TODO: This blanket reinstalls things, even if no_deps is set.
pkg_set.resolve_set(req_set, check_existing=not reinstall)
# Install and/or link.
pkg_set.install(subset or None,
link_env=env,
reinstall=reinstall,
relink=relink,
no_deps=no_deps)
if pkg_set._errored and not force_branch_link:
log.warning(
style_warning(
"Not creating branch or version links; force with --force-branch-link"
))
return False
# Create a symlink by branch.
path_by_branch = self.home._abs_path('environments', self.name,
self.branch_name)
if os.path.lexists(path_by_branch):
os.unlink(path_by_branch)
makedirs(os.path.dirname(path_by_branch))
os.symlink(env.path, path_by_branch)
# Create a symlink by version.
version = req_set.headers.get('Version')
if version:
path_by_version = self.home._abs_path(
'environments', self.name, 'versions',
version.value + ('-dirty' if dirty else ''))
if os.path.lexists(path_by_version):
os.unlink(path_by_version)
makedirs(os.path.dirname(path_by_version))
os.symlink(env.path, path_by_version)
return True
def link(args):
"""Link the given requirement or requirements into the given environment,
e.g.::
# Install and link a single package.
$ vee link [email protected]:vfxetc/sgmock
# Install and link multiple packages.
$ vee link [email protected]:vfxetc/sgmock [email protected]:vfxetc/sgsession \\
http:/example.org/path/to/tarball.tgz --make-install
# Install and link from a requirement set.
$ vee link path/to/manifest.txt
"""
if args.no_install and args.re_install:
raise ValueError(
'please use only one of --no-install and --re-install')
home = args.assert_home()
if sum(
int(bool(x))
for x in (args.repo, args.environment, args.directory)) > 1:
raise ValueError(
'use only one of --repo, --environment, or --directory')
if args.environment:
env = Environment(args.environment, home=home)
elif args.directory:
env = Environment(os.path.abspath(args.directory), home=home)
else:
repo = home.get_repo(args.repo)
env = Environment('%s/%s' % (repo.name, repo.branch_name), home=home)
if args.raw:
for dir_ in args.requirements:
log.info(style_note('Linking', dir_))
env.link_directory(dir_)
return
manifest = Manifest(args.requirements, home=home)
pkg_set = PackageSet(env=env, home=home)
# Register the whole set, so that dependencies are pulled from here instead
# of weakly resolved from installed packages.
pkg_set.resolve_set(manifest)
for req in manifest.iter_packages():
# Skip if it wasn't requested.
if args.subset and req.name not in args.subset:
continue
log.info(style('==> %s' % req.name, 'blue'))
pkg = pkg_set.resolve(req, check_existing=not args.reinstall)
if args.no_install and not pkg.installed:
raise CliError('not installed: %s' % req)
try:
with log.indent():
pkg_set.install(pkg.name,
link_env=env,
reinstall=args.reinstall,
relink=args.force)
except AlreadyInstalled:
pass
except AlreadyLinked as e:
log.info(style('Already linked ', 'blue') + str(req), verbosity=1)
except Exception as e:
print_cli_exc(e, verbose=True)
log.exception('Failed to link %s' % req)
continue