def update(self):
acted = False
if not os.path.exists(self._get_destination()):
self.install()
return True
if self.source.get('url') != self.target.get('url'):
acted = True
if os.path.exists(self.directory.install_directory(self.feature_name)):
try:
self.directory.remove_feature(self.feature_name)
except DirectoryException:
self.logger.exception()
self.logger.error("Unable to remove old directory!")
self.__install(self.target)
if self.source.has('executable'):
symlink = self.source.get('symlink', self.source.get('executable'))
if os.path.exists(symlink) and os.path.islink(symlink):
try:
self.directory.remove_from_bin(
self.source('symlink', self.source.get('executable')))
acted = True
except DirectoryException:
pass
if self.target.has('executable'):
symlink = self.target.get('symlink', self.target.get('executable'))
if not os.path.exists(symlink):
acted = True
self.__symlink_executable(self.target.get('executable'),
symlink)
FormulaBase.update(self)
return acted
def validate(self):
FormulaBase.validate(self)
config = self.target or self.source
version = config.get('version', 'r13.2')
if version not in package_dict:
raise PerforceFormulaException("Version %s in not supported by perforce formula!\n" % version +
"Supported versions are: %s" % ", ".join(package_dict.keys()))
def validate(self):
if self.target:
if (self.target.has('username') and not self.target.has('password') or
self.target.has('password') and not self.target.has('username')):
self.logger.warn("Username and password are " +
"both required to authenticate to a source!")
FormulaBase.validate(self)
def update(self):
acted = False
if self.target.has('on_update') and self.target.is_affirmative('on_update'):
self.__install_file(self.target)
acted = True
FormulaBase.update(self)
return acted
def install(self):
if not lib.which('git'):
self.logger.warn(
"git is not installed! Please install git to install this feature."
)
return
install_dir = self.directory.install_directory(self.feature_name)
git_root = self.target.get('git_root', None)
target_path = git_root or install_dir
target_branch = self.target.get('branch', 'master')
git_opts = {
'repo': self.target.get('url', None),
'branch': target_branch,
'dir': target_path
}
# no existing path is given or the path is not a git repo
if (not target_path or not os.path.exists(target_path)
or not self.__git(CURRENT_BRANCH, git_opts)[1]):
self.__clone_repo(git_opts)
# for an existing path, the git remote must match
elif self.__git(CURRENT_REMOTE, git_opts)[1] != self.target.get('url'):
raise GitException('Incorrect origin for local repo!')
if self.__git(CURRENT_BRANCH, git_opts)[1] != target_branch:
self.__checkout_branch(git_opts)
FormulaBase.install(self)
def update(self):
acted = False
if not os.path.exists(self._get_destination()):
self.install()
return True
if self.source.get('url') != self.target.get('url'):
acted = True
if os.path.exists(
self.directory.install_directory(self.feature_name)):
try:
self.directory.remove_feature(self.feature_name)
except DirectoryException:
self.logger.exception()
self.logger.error("Unable to remove old directory!")
self.__install(self.target)
if self.source.has('executable'):
symlink = self.source.get('symlink', self.source.get('executable'))
if os.path.exists(symlink) and os.path.islink(symlink):
try:
self.directory.remove_from_bin(
self.source('symlink', self.source.get('executable')))
acted = True
except DirectoryException:
pass
if self.target.has('executable'):
symlink = self.target.get('symlink', self.target.get('executable'))
if not os.path.exists(symlink):
acted = True
self.__symlink_executable(self.target.get('executable'),
symlink)
FormulaBase.update(self)
return acted
def test_debianbased_only(self):
""" Test a feature that should only occur on debian-based distributions """
fb = FormulaBase(self.environment, "debian", target=self.environment.target.get_feature_config("debian"))
with patch("sprinter.lib.system.is_debian") as is_debian:
is_debian.return_value = True
assert fb.should_run()
is_debian.return_value = False
assert not fb.should_run()
def update(self):
acted = False
if self.target.has('on_update') and self.target.is_affirmative(
'on_update'):
self.__install_file(self.target)
acted = True
FormulaBase.update(self)
return acted
def install(self):
self.__install(self.target)
if self.target.has('executable'):
symlink_target = self.target.get('symlink',
self.target.get('executable'))
self.__symlink_executable(self.target.get('executable'),
symlink_target)
FormulaBase.install(self)
def install(self):
if not lib.which('git'):
self.logger.warn("git is not installed! Please install git to install this feature.")
return
self.__clone_repo(self.target.get('url'),
self.directory.install_directory(self.feature_name),
branch=self.target.get('branch', 'master'))
FormulaBase.install(self)
def validate(self):
if self.target:
if (self.target.has('username') and not self.target.has('password')
or self.target.has('password')
and not self.target.has('username')):
self.logger.warn("Username and password are " +
"both required to authenticate to a source!")
FormulaBase.validate(self)
def install(self):
self.__install(self.target)
if self.target.has('executable'):
symlink_target = self.target.get('symlink',
self.target.get('executable'))
self.__symlink_executable(self.target.get('executable'),
symlink_target)
FormulaBase.install(self)
def update(self):
acted = False
if self.source.get('version', 'r13.2') != self.target.get('version', 'r13.2'):
os.unlink(os.path.join(self.directory.install_directory(self.feature_name), 'p4'))
self.__install_perforce(self.target)
acted = True
self.__add_p4_env(self.target)
FormulaBase.update(self)
return acted
def update(self):
acted = False
if self.source.get('version', 'r13.2') != self.target.get('version', 'r13.2'):
os.unlink(os.path.join(self.directory.install_directory(self.feature_name), 'p4'))
self.__install_perforce(self.target)
acted = True
self.__add_p4_env(self.target)
FormulaBase.update(self)
return acted
def test_prompt_value_default(self):
""" _prompt_value default should be overwritten by the source if it exists """
fb = FormulaBase(self.environment, 'prompt_value',
source=self.environment.source.get_feature_config('prompt_value_source'),
target=self.environment.target.get_feature_config('prompt_value_source'))
with patch('sprinter.lib.prompt') as prompt:
prompt.return_value = "foo"
fb._prompt_value('source_value', 'this value exists')
prompt.assert_called_once_with('this value exists', default="old")
def install(self):
if not lib.which('git'):
self.logger.warn(
"git is not installed! Please install git to install this feature."
)
return
self.__clone_repo(self.target.get('url'),
self.directory.install_directory(self.feature_name),
branch=self.target.get('branch', 'master'))
FormulaBase.install(self)
def update(self):
acted = False
if (self.source.get('egg', '') != self.target.get('egg', '') or
self.source.get('eggs', '') != self.target.get('eggs', '') or
(self.target.has('redownload') and self.target.is_affirmative('redownload'))):
self.__install_eggs(self.target)
acted = True
self.__add_paths(self.target)
FormulaBase.update(self)
return acted
def test_resolve_dont_carry_over_options(self):
""" resolve should resolve non-carry over options """
fb = FormulaBase(
self.environment,
'prompt_value',
source=self.environment.source.get_feature_config('resolve'),
target=self.environment.target.get_feature_config('resolve'))
fb.resolve()
assert not fb.target.has('systems')
assert not fb.target.has('depends')
def remove(self):
if self.source.has('executable'):
symlink = self.source.get('symlink', self.source.get('executable'))
if os.path.exists(symlink) and os.path.islink(symlink):
try:
self.directory.remove_from_bin(
self.source('symlink', self.source.get('executable')))
except DirectoryException:
pass
FormulaBase.remove(self)
def test_prompt_value(self):
""" _prompt_value should prompt a value if it does not exist in the target """
fb = FormulaBase(self.environment, 'prompt_value',
target=self.environment.target.get_feature_config('prompt_value'))
with patch('sprinter.lib.prompt') as prompt:
prompt.return_value = "foo"
fb._prompt_value('existing_value', 'this value exists')
assert fb.target.get('existing_value') == "here"
fb._prompt_value('non_existing_value', "this value doesn't exists")
assert fb.target.get('non_existing_value') == "foo"
def update(self):
acted = False
if (self.source.get('egg', '') != self.target.get('egg', '') or
self.source.get('eggs', '') != self.target.get('eggs', '') or
(self.target.has('redownload') and self.target.is_affirmative('redownload'))):
self.__install_eggs(self.target)
acted = True
self.__add_paths(self.target)
FormulaBase.update(self)
return acted
def remove(self):
if self.source.has('executable'):
symlink = self.source.get('symlink', self.source.get('executable'))
if os.path.exists(symlink) and os.path.islink(symlink):
try:
self.directory.remove_from_bin(
self.source('symlink', self.source.get('executable')))
except DirectoryException:
pass
FormulaBase.remove(self)
def test_debianbased_only(self):
""" Test a feature that should only occur on debian-based distributions """
fb = FormulaBase(
self.environment,
'debian',
target=self.environment.target.get_feature_config('debian'))
with patch('sprinter.lib.system.is_debian') as is_debian:
is_debian.return_value = True
assert fb.should_run()
is_debian.return_value = False
assert not fb.should_run()
def test_resolve_dont_carry_over_options(self):
""" resolve should resolve non-carry over options """
fb = FormulaBase(
self.environment,
"prompt_value",
source=self.environment.source.get_feature_config("resolve"),
target=self.environment.target.get_feature_config("resolve"),
)
fb.resolve()
assert not fb.target.has("systems")
assert not fb.target.has("depends")
def validate(self):
FormulaBase.validate(self)
if self.target:
versions = self.target.get('version').split('.')
if len(versions) != 3:
self._log_error("Version string %s is invalid! please format it as : X.X.X")
for v in versions:
try:
int(v)
except ValueError:
self._log_error("Versions must all be integers! %s is not one" % v)
def update(self):
self.__get_package_manager()
install_package = False
if self.package_manager and self.target.has(self.package_manager):
if not self.source.has(self.package_manager):
install_package = True
if self.source.get(self.package_manager) != self.target.get(self.package_manager):
install_package = True
if install_package:
self.__install_package(self.target)
FormulaBase.update(self)
def update(self):
self.__get_package_manager()
install_package = False
if self.package_manager and self.target.has(self.package_manager):
if not self.source.has(self.package_manager):
install_package = True
if self.source.get(self.package_manager) != self.target.get(
self.package_manager):
install_package = True
if install_package:
self.__install_package(self.target)
FormulaBase.update(self)
def test_prompt_value_default(self):
""" _prompt_value default should be overwritten by the source if it exists """
fb = FormulaBase(self.environment,
'prompt_value',
source=self.environment.source.get_feature_config(
'prompt_value_source'),
target=self.environment.target.get_feature_config(
'prompt_value_source'))
with patch('sprinter.lib.prompt') as prompt:
prompt.return_value = "foo"
fb._prompt_value('source_value', 'this value exists')
prompt.assert_called_once_with('this value exists', default="old")
def test_prompt_value_default(self):
""" _prompt_value default should be overwritten by the source if it exists """
fb = FormulaBase(
self.environment,
"prompt_value",
source=self.environment.source.get_feature_config("prompt_value_source"),
target=self.environment.target.get_feature_config("prompt_value_source"),
)
with patch("sprinter.lib.prompt") as prompt:
prompt.return_value = "foo"
fb._prompt_value("source_value", "this value exists")
prompt.assert_called_once_with("this value exists", default="old")
def update(self):
fresh = False
if self.source.get('version') != self.target.get('version'):
self.directory.remove_feature(self.feature_name)
fresh = True
if not os.path.exists(
self.directory.install_directory(self.feature_name)):
fresh = True
if fresh:
self._install_node()
self._link_executables()
self._install_packages(fresh=fresh)
FormulaBase.update(self)
def validate(self):
FormulaBase.validate(self)
if self.target:
versions = self.target.get('version').split('.')
if len(versions) != 3:
self._log_error(
"Version string %s is invalid! please format it as : X.X.X"
)
for v in versions:
try:
int(v)
except ValueError:
self._log_error(
"Versions must all be integers! %s is not one" % v)
def install(self):
config = self.target
self.p4environ = dict(list(os.environ.items()) + [('P4USER', config.get('username')),
('P4PASSWD', config.get('password')),
('P4CLIENT', config.get('client'))])
installed = self.__install_perforce(config)
if not os.path.exists(os.path.expanduser(config.get('root_path'))):
os.makedirs(os.path.expanduser(config['root_path']))
if config.is_affirmative('write_p4settings'):
self.__write_p4settings(config)
if config.is_affirmative('overwrite_client') and installed:
self.__configure_client(config)
self.__add_p4_env(config)
FormulaBase.install(self)
def update(self):
fresh = False
if self.source.get('version') != self.target.get('version'):
self.directory.remove_feature(self.feature_name)
fresh = True
if not os.path.exists(
self.directory.install_directory(self.feature_name)
):
fresh = True
if fresh:
self._install_node()
self._link_executables()
self._install_packages(fresh=fresh)
FormulaBase.update(self)
def install(self):
create_virtualenv(self.directory.install_directory(self.feature_name),
search_dirs=file_search_dirs(),
symlink=True)
self.__install_eggs(self.target)
self.__add_paths(self.target)
return FormulaBase.install(self)
def validate(self):
if self.target:
if not (self.target.has('egg') or self.target.has('eggs')):
self.logger.warn(
"No eggs will be installed! 'egg' or 'eggs' parameter not set!"
)
return FormulaBase.validate(self)
def update(self):
if not lib.which('git'):
self.logger.warn(
"git is not installed! Please install git to install this feature."
)
return
install_dir = self.directory.install_directory(self.feature_name)
git_root = self.target.get('git_root', None)
target_path = git_root or install_dir
source_branch = self.source.get('branch', 'master')
target_branch = self.target.get('branch', 'master')
git_opts = {
'repo': self.target.get('url'),
'branch': target_branch,
'dir': target_path
}
# directory doesn't exist, or is not a git branch
if (not target_path or not os.path.exists(target_path)
or not self.__git(CURRENT_BRANCH, git_opts)[1]):
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(git_opts)
current_remote = self.__git(CURRENT_REMOTE, git_opts)[1]
current_branch = self.__git(CURRENT_BRANCH, git_opts)[1]
# for an existing path, the git remote must match
if current_remote != self.target.get('url'):
self.logger.debug("Updating origin url...")
self.__git(UPDATE_ORIGIN, git_opts)
if current_branch != target_branch:
# update using "fetch origin [branch]:[branch]"
self.__git(UPDATE_OFFLINE_BRANCH, git_opts)
else:
self.__fetch_merge_repo(git_opts)
# change branches if the manifest has changed,
# don't change branches if the user has changed branches
if current_branch == source_branch and current_branch != target_branch:
self.__checkout_branch(git_opts)
FormulaBase.update(self)
return True
def update(self):
source_opts = self.__get_options(self.source)
target_opts = self.__get_options(self.target)
# compare old and new link source and link target
if (source_opts['source'] != target_opts['source']
or source_opts['target'] != target_opts['target']):
self.__remove_symlink(**source_opts)
self.__create_symlink(**target_opts)
return FormulaBase.update(self)
def update(self):
source_opts = self.__get_options(self.source)
target_opts = self.__get_options(self.target)
# compare old and new link source and link target
if (source_opts['source'] != target_opts['source'] or
source_opts['target'] != target_opts['target']):
self.__remove_symlink(**source_opts)
self.__create_symlink(**target_opts)
return FormulaBase.update(self)
def update(self):
if not lib.which('git'):
self.logger.warn(
"git is not installed! Please install git to install this feature."
)
return
target_directory = self.directory.install_directory(self.feature_name)
source_branch = self.source.get('branch', 'master')
target_branch = self.target.get('branch', 'master')
if not os.path.exists(target_directory):
# directory doesn't exist, so we just clone again
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
if self.target.get('url') != self.source.get('url'):
self.logger.debug("Old git repository Found. Deleting...")
self.directory.remove_feature(self.feature_name)
self.__clone_repo(self.target.get('url'),
target_directory,
branch=self.target.get('branch', 'master'))
elif source_branch != target_branch:
self.__checkout_branch(target_directory, target_branch)
else:
if not os.path.exists(target_directory):
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
os.chdir(target_directory)
error, output = lib.call("git pull origin %s" % target_branch,
output_log_level=logging.DEBUG)
if error:
self.logger.info(output)
raise GitException("An error occurred when pulling!")
FormulaBase.update(self)
def validate(self):
if self.target:
target_opts = self.__get_options(self.target)
for k in self._required_options:
if k not in target_opts:
error_message = "Required option {option} not present in feature {feature}!".format(
option=k, feature=self.feature_name)
if self.target.is_affirmative('fail_on_error', False):
self._log_error(error_message)
else:
self.logger.error(error_message)
return FormulaBase.validate(self)
def validate(self):
if self.target:
target_opts = self.__get_options(self.target)
for k in self._required_options:
if k not in target_opts:
error_message = "Required option {option} not present in feature {feature}!".format(
option=k, feature=self.feature_name)
if self.target.is_affirmative('fail_on_error', False):
self._log_error(error_message)
else:
self.logger.error(error_message)
return FormulaBase.validate(self)
def update(self):
if not lib.which('git'):
self.logger.warn("git is not installed! Please install git to install this feature.")
return
target_directory = self.directory.install_directory(self.feature_name)
source_branch = self.source.get('branch', 'master')
target_branch = self.target.get('branch', 'master')
if not os.path.exists(target_directory):
# directory doesn't exist, so we just clone again
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
if self.target.get('url') != self.source.get('url'):
self.logger.debug("Old git repository Found. Deleting...")
self.directory.remove_feature(self.feature_name)
self.__clone_repo(self.target.get('url'),
target_directory,
branch=self.target.get('branch', 'master'))
elif source_branch != target_branch:
self.__checkout_branch(target_directory, target_branch)
else:
if not os.path.exists(target_directory):
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
os.chdir(target_directory)
error, output = lib.call("git pull origin %s" % target_branch,
output_log_level=logging.DEBUG)
if error:
self.logger.info(output)
raise GitException("An error occurred when pulling!")
FormulaBase.update(self)
def update(self):
if not lib.which('git'):
self.logger.warn(
"git is not installed! Please install git to install this feature."
)
return
target_directory = self.directory.install_directory(self.feature_name)
source_branch = self.source.get('branch', 'master')
target_branch = self.target.get('branch', 'master')
if not os.path.exists(target_directory):
# directory doesn't exist, so we just clone again
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
if self.target.get('url') != self.source.get('url'):
self.logger.debug("Old git repository Found. Deleting...")
self.directory.remove_feature(self.feature_name)
self.__clone_repo(self.target.get('url'),
target_directory,
branch=self.target.get('branch', 'master'))
elif source_branch != target_branch:
self.__checkout_branch(target_directory, target_branch)
else:
if not os.path.exists(target_directory):
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
self.__fetch_merge_repo(target_directory, target_branch)
FormulaBase.update(self)
return True
def test_osx_only(self):
""" Test a feature that should only occur on osx """
fb = FormulaBase(
self.environment,
'osx',
target=self.environment.target.get_feature_config('osx'))
fb2 = FormulaBase(
self.environment,
'osx2',
target=self.environment.target.get_feature_config('osx2'))
with patch('sprinter.lib.system.is_osx') as is_osx:
is_osx.return_value = True
assert fb.should_run()
assert fb2.should_run()
is_osx.return_value = False
assert not fb.should_run()
assert not fb2.should_run()
def update(self):
if not lib.which('git'):
self.logger.warn("git is not installed! Please install git to install this feature.")
return
target_directory = self.directory.install_directory(self.feature_name)
source_branch = self.source.get('branch', 'master')
target_branch = self.target.get('branch', 'master')
if not os.path.exists(target_directory):
# directory doesn't exist, so we just clone again
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
if self.target.get('url') != self.source.get('url'):
self.logger.debug("Old git repository Found. Deleting...")
self.directory.remove_feature(self.feature_name)
self.__clone_repo(self.target.get('url'),
target_directory,
branch=self.target.get('branch', 'master'))
elif source_branch != target_branch:
self.__checkout_branch(target_directory, target_branch)
else:
if not os.path.exists(target_directory):
self.logger.debug("No repository cloned. Re-cloning...")
self.__clone_repo(self.target.get('url'),
target_directory,
branch=target_branch)
self.__fetch_merge_repo(target_directory, target_branch)
FormulaBase.update(self)
return True
def test_osx_only(self):
""" Test a feature that should only occur on osx """
fb = FormulaBase(self.environment, "osx", target=self.environment.target.get_feature_config("osx"))
fb2 = FormulaBase(self.environment, "osx2", target=self.environment.target.get_feature_config("osx2"))
with patch("sprinter.lib.system.is_osx") as is_osx:
is_osx.return_value = True
assert fb.should_run()
assert fb2.should_run()
is_osx.return_value = False
assert not fb.should_run()
assert not fb2.should_run()
def test_prompt_value(self):
""" _prompt_value should prompt a value if it does not exist in the target """
fb = FormulaBase(
self.environment,
'prompt_value',
target=self.environment.target.get_feature_config('prompt_value'))
with patch('sprinter.lib.prompt') as prompt:
prompt.return_value = "foo"
fb._prompt_value('existing_value', 'this value exists')
assert fb.target.get('existing_value') == "here"
fb._prompt_value('non_existing_value', "this value doesn't exists")
assert fb.target.get('non_existing_value') == "foo"
def remove(self):
if self.source.is_affirmative('remove_file_on_delete', False):
os.path.unlink(os.path.expanduser(self.source.get('target')))
FormulaBase.remove(self)
def update(self):
if self.target.has('on_update') and self.target.is_affirmative(
'on_update'):
self.__install_file(self.target)
FormulaBase.update(self)
def install(self):
self.__install_file(self.target)
FormulaBase.install(self)
def activate(self):
self.__run_command('activate', 'source')
FormulaBase.activate(self)
def remove(self):
self.__run_command('remove', 'source')
FormulaBase.remove(self)
def deactivate(self):
self.__run_command('deactivate', 'source')
FormulaBase.deactivate(self)
def validate(self):
if self.target:
if not (self.target.has('egg') or self.target.has('eggs')):
self.logger.warn("No eggs will be installed! 'egg' or 'eggs' parameter not set!")
return FormulaBase.validate(self)
def update(self):
for c in (c for c in self.target.keys() if c not in self.ignored_keys):
self.directory.add_to_env('export %s=%s' % (c.upper(), self.target.get(c)))
FormulaBase.update(self)
def install(self):
create_virtualenv(self.directory.install_directory(self.feature_name),
search_dirs=file_search_dirs(), symlink=True)
self.__install_eggs(self.target)
self.__add_paths(self.target)
return FormulaBase.install(self)
def deactivate(self):
self.__run_command('deactivate', 'source')
FormulaBase.deactivate(self)
def install(self):
self.__get_package_manager()
self.__install_package(self.target)
FormulaBase.install(self)
