def _cleanup_common_directories(config):
_remove_directory_if_empty(common.get_partsdir())
_remove_directory_if_empty(common.get_stagedir())
_remove_directory_if_empty(common.get_snapdir())
max_index = -1
for part in config.all_parts:
step = part.last_step()
if step:
index = common.COMMAND_ORDER.index(step)
if index > max_index:
max_index = index
# If no parts have been pulled, remove the parts directory. In most cases
# this directory should have already been cleaned, but this handles the
# case of a failed pull.
should_remove_partsdir = max_index < common.COMMAND_ORDER.index('pull')
if should_remove_partsdir and os.path.exists(common.get_partsdir()):
logger.info('Cleaning up parts directory')
shutil.rmtree(common.get_partsdir())
# If no parts have been staged, remove staging area.
should_remove_stagedir = max_index < common.COMMAND_ORDER.index('stage')
if should_remove_stagedir and os.path.exists(common.get_stagedir()):
logger.info('Cleaning up staging area')
shutil.rmtree(common.get_stagedir())
# If no parts have been stripped, remove snapping area.
should_remove_snapdir = max_index < common.COMMAND_ORDER.index('strip')
if should_remove_snapdir and os.path.exists(common.get_snapdir()):
logger.info('Cleaning up snapping area')
shutil.rmtree(common.get_snapdir())
def test_partial_clean(self):
parts = self.make_snapcraft_yaml(n=3)
main(["clean", "clean0", "clean2"])
for i in [0, 2]:
self.assertFalse(
os.path.exists(parts[i]["part_dir"]), "Expected for {!r} to be wiped".format(parts[i]["part_dir"])
)
self.assertTrue(os.path.exists(parts[1]["part_dir"]), "Expected a part directory for the clean1 part")
self.assertTrue(os.path.exists(common.get_partsdir()))
self.assertTrue(os.path.exists(common.get_stagedir()))
self.assertTrue(os.path.exists(common.get_snapdir()))
# Now clean it the rest of the way
main(["clean", "clean1"])
for i in range(0, 3):
self.assertFalse(
os.path.exists(parts[i]["part_dir"]), "Expected for {!r} to be wiped".format(parts[i]["part_dir"])
)
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_partial_clean(self):
parts = self.make_snapcraft_yaml(n=3)
clean.main(['clean0', 'clean2'])
for i in [0, 2]:
self.assertFalse(
os.path.exists(parts[i]['part_dir']),
'Expected for {!r} to be wiped'.format(parts[i]['part_dir']))
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the clean1 part')
self.assertTrue(os.path.exists(common.get_partsdir()))
self.assertTrue(os.path.exists(common.get_stagedir()))
self.assertTrue(os.path.exists(common.get_snapdir()))
# Now clean it the rest of the way
clean.main(['clean1'])
for i in range(0, 3):
self.assertFalse(
os.path.exists(parts[i]['part_dir']),
'Expected for {!r} to be wiped'.format(parts[i]['part_dir']))
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_clean_all(self):
cmds.clean({})
self.mock_exists.assert_has_calls([
mock.call('partdir1'),
mock.call().__bool__(),
mock.call('partdir2'),
mock.call().__bool__(),
mock.call('partdir3'),
mock.call().__bool__(),
mock.call(common.get_partsdir()),
mock.call().__bool__(),
mock.call(common.get_stagedir()),
mock.call().__bool__(),
mock.call(common.get_snapdir()),
mock.call().__bool__(),
])
self.mock_rmtree.assert_has_calls([
mock.call('partdir1'),
mock.call('partdir2'),
mock.call('partdir3'),
mock.call(common.get_stagedir()),
mock.call(common.get_snapdir()),
])
self.mock_rmdir.assert_called_once_with(common.get_partsdir())
def test_clean_all(self):
cmds.clean({})
self.mock_exists.assert_has_calls([
mock.call('partdir1'),
mock.call().__bool__(),
mock.call('partdir2'),
mock.call().__bool__(),
mock.call('partdir3'),
mock.call().__bool__(),
mock.call(common.get_partsdir()),
mock.call().__bool__(),
mock.call(common.get_stagedir()),
mock.call().__bool__(),
mock.call(common.get_snapdir()),
mock.call().__bool__(),
])
self.mock_rmtree.assert_has_calls([
mock.call('partdir1'),
mock.call('partdir2'),
mock.call('partdir3'),
mock.call(common.get_stagedir()),
mock.call(common.get_snapdir()),
])
self.mock_rmdir.assert_called_once_with(common.get_partsdir())
def clean(args):
config = _load_config()
part_names = {part.name for part in config.all_parts}
for part_name in args.parts:
if part_name not in part_names:
logger.error('The part named {!r} is not defined in '
'\'snapcraft.yaml\''.format(part_name))
sys.exit(1)
for part in config.all_parts:
if not args.parts or part.name in args.parts:
part.clean()
# parts dir does not contain only generated code.
if (os.path.exists(common.get_partsdir()) and
not os.listdir(common.get_partsdir())):
os.rmdir(common.get_partsdir())
clean_stage = not args.parts or part_names == set(args.parts)
if clean_stage and os.path.exists(common.get_stagedir()):
logger.info('Cleaning up staging area')
shutil.rmtree(common.get_stagedir())
if os.path.exists(common.get_snapdir()):
logger.info('Cleaning up snapping area')
shutil.rmtree(common.get_snapdir())
def main(argv=None):
argv = argv if argv else []
args = docopt(__doc__, argv=argv)
config = snapcraft.yaml.load_config()
if args['PART']:
config.validate_parts(args['PART'])
for part in config.all_parts:
if not args['PART'] or part.name in args['PART']:
part.clean()
# parts dir does not contain only generated code.
if (os.path.exists(common.get_partsdir()) and
not os.listdir(common.get_partsdir())):
os.rmdir(common.get_partsdir())
parts_match = set(config.part_names) == set(args['PART'])
# Only clean stage if all the parts were cleaned up.
clean_stage = not args['PART'] or parts_match
if clean_stage and os.path.exists(common.get_stagedir()):
logger.info('Cleaning up staging area')
shutil.rmtree(common.get_stagedir())
if os.path.exists(common.get_snapdir()):
logger.info('Cleaning up snapping area')
shutil.rmtree(common.get_snapdir())
def clear_common_directories(self):
if os.path.exists(common.get_partsdir()):
shutil.rmtree(common.get_partsdir())
if os.path.exists(common.get_stagedir()):
shutil.rmtree(common.get_stagedir())
if os.path.exists(common.get_snapdir()):
shutil.rmtree(common.get_snapdir())
def test_state_file_migration(self):
part_name = 'foo'
for step in common.COMMAND_ORDER:
shutil.rmtree(common.get_partsdir())
with self.subTest('{} step'.format(step)):
part_dir = os.path.join(common.get_partsdir(), part_name)
os.makedirs(part_dir)
with open(os.path.join(part_dir, 'state'), 'w') as f:
f.write(step)
handler = pluginhandler.load_plugin(part_name, 'nil')
self.assertEqual(step, handler.last_step())
def test_clean_nested_dependent_parts(self):
yaml = """name: clean-test
version: 1.0
summary: test clean
description: test clean
parts:
main:
plugin: nil
source: .
dependent:
plugin: nil
source: .
after: [main]
dependent-dependent:
plugin: nil
source: .
after: [dependent]"""
super().make_snapcraft_yaml(yaml)
part_dirs = {}
for part in ['main', 'dependent', 'dependent-dependent']:
part_dirs[part] = os.path.join(common.get_partsdir(), part)
os.makedirs(part_dirs[part])
os.makedirs(common.get_stagedir())
os.makedirs(common.get_snapdir())
# Cleaning only `main`. Since `dependent` depends upon main, we expect
# that it will be cleaned as well. Otherwise it won't be using the new
# `main` when it is built.
clean.main(['main'])
self.assertFalse(os.path.exists(part_dirs['main']),
'Expected part directory for main to be cleaned')
self.assertFalse(
os.path.exists(part_dirs['dependent']),
'Expected part directory for dependent to be cleaned as it '
'depends upon main')
self.assertFalse(
os.path.exists(part_dirs['dependent-dependent']),
'Expected part directory for dependent-dependent to be cleaned as '
'it depends upon dependent, which depends upon main')
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_cleanbuild(self, mock_installed, mock_call):
mock_installed.return_value = True
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
self.make_snapcraft_yaml()
# simulate build artifacts
dirs = [
os.path.join(common.get_partsdir(), 'part1', 'src'),
common.get_stagedir(),
common.get_snapdir(),
os.path.join(common.get_partsdir(), 'plugins'),
]
files_tar = [
os.path.join(common.get_partsdir(), 'plugins', 'x-plugin.py'),
'main.c',
]
files_no_tar = [
os.path.join(common.get_stagedir(), 'binary'),
os.path.join(common.get_snapdir(), 'binary'),
'snap-test.snap',
'snap-test_1.0_source.tar.bz2',
]
for d in dirs:
os.makedirs(d)
for f in files_tar + files_no_tar:
open(f, 'w').close()
cleanbuild.main()
self.assertEqual(
'Setting up container with project assets\n'
'Waiting for a network connection...\n'
'Network connection established\n'
'Retrieved snap-test_1.0_amd64.snap\n',
fake_logger.output)
with tarfile.open('snap-test_1.0_source.tar.bz2') as tar:
tar_members = tar.getnames()
for f in files_no_tar:
f = os.path.relpath(f)
self.assertFalse('./{}'.format(f) in tar_members,
'{} should not be in {}'.format(f, tar_members))
for f in files_tar:
f = os.path.relpath(f)
self.assertTrue('./{}'.format(f) in tar_members,
'{} should be in {}'.format(f, tar_members))
def test_cleanbuild(self, mock_installed, mock_call):
mock_installed.return_value = True
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
self.make_snapcraft_yaml()
# simulate build artifacts
dirs = [
os.path.join(common.get_partsdir(), 'part1', 'src'),
common.get_stagedir(),
common.get_snapdir(),
os.path.join(common.get_partsdir(), 'plugins'),
]
files_tar = [
os.path.join(common.get_partsdir(), 'plugins', 'x-plugin.py'),
'main.c',
]
files_no_tar = [
os.path.join(common.get_stagedir(), 'binary'),
os.path.join(common.get_snapdir(), 'binary'),
'snap-test.snap',
'snap-test_1.0_source.tar.bz2',
]
for d in dirs:
os.makedirs(d)
for f in files_tar + files_no_tar:
open(f, 'w').close()
cleanbuild.main()
self.assertEqual(
'Setting up container with project assets\n'
'Waiting for a network connection...\n'
'Network connection established\n'
'Retrieved snap-test_1.0_amd64.snap\n', fake_logger.output)
with tarfile.open('snap-test_1.0_source.tar.bz2') as tar:
tar_members = tar.getnames()
for f in files_no_tar:
f = os.path.relpath(f)
self.assertFalse('./{}'.format(f) in tar_members,
'{} should not be in {}'.format(f, tar_members))
for f in files_tar:
f = os.path.relpath(f)
self.assertTrue('./{}'.format(f) in tar_members,
'{} should be in {}'.format(f, tar_members))
def test_strip_defaults(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
strip.main()
self.assertTrue(os.path.exists(common.get_snapdir()),
'Expected a snap directory')
self.assertTrue(
os.path.exists(
os.path.join(common.get_snapdir(), 'meta', 'snap.yaml')),
'Expected a snap.yaml')
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the build0 part')
self.assertTrue(os.path.exists(parts[0]['state_file']),
'Expected a state file for the build0 part')
with open(parts[0]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(len(state), 1, 'Expected only one line in the state '
'file for the build0 part')
self.assertEqual(state[0], 'strip', "Expected the state file for "
"build0 to be 'strip'")
def test_wrap_exe_writes_wrapper_with_basename(self, mock_assemble_env):
mock_assemble_env.return_value = """\
PATH={0}/part1/install/usr/bin:{0}/part1/install/bin
""".format(common.get_partsdir())
snapdir = common.get_snapdir()
os.mkdir(snapdir)
relative_exe_path = 'test_relexepath'
open(os.path.join(snapdir, relative_exe_path), 'w').close()
relative_wrapper_path = meta._wrap_exe(
relative_exe_path, basename='new-name')
wrapper_path = os.path.join(snapdir, relative_wrapper_path)
self.assertEqual(relative_wrapper_path, 'new-name.wrapper')
expected = ('#!/bin/sh\n'
'PATH=$SNAP/usr/bin:$SNAP/bin\n'
'\n\n'
'exec "$SNAP/test_relexepath" $*\n')
with open(wrapper_path) as wrapper_file:
wrapper_contents = wrapper_file.read()
self.assertEqual(expected, wrapper_contents)
def test_wrap_exe_writes_wrapper_with_basename(self, mock_assemble_env):
mock_assemble_env.return_value = """\
PATH={0}/part1/install/usr/bin:{0}/part1/install/bin
""".format(common.get_partsdir())
snapdir = common.get_snapdir()
os.mkdir(snapdir)
relative_exe_path = 'test_relexepath'
open(os.path.join(snapdir, relative_exe_path), 'w').close()
relative_wrapper_path = meta._wrap_exe(relative_exe_path,
basename='new-name')
wrapper_path = os.path.join(snapdir, relative_wrapper_path)
self.assertEqual(relative_wrapper_path, 'new-name.wrapper')
expected = ('#!/bin/sh\n'
'PATH=$SNAP/usr/bin:$SNAP/bin\n'
'\n\n'
'exec "$SNAP/test_relexepath" $*\n')
with open(wrapper_path) as wrapper_file:
wrapper_contents = wrapper_file.read()
self.assertEqual(expected, wrapper_contents)
def test_wrap_exe_must_write_wrapper(self, mock_assemble_env):
mock_assemble_env.return_value = """\
PATH={0}/part1/install/usr/bin:{0}/part1/install/bin
""".format(common.get_partsdir())
snapdir = common.get_snapdir()
os.mkdir(snapdir)
relative_exe_path = 'test_relexepath'
open(os.path.join(snapdir, relative_exe_path), 'w').close()
# Check that the wrapper is created even if there is already a file
# with the same name.
open(os.path.join('snap', 'test_relexepath.wrapper'), 'w').close()
relative_wrapper_path = meta._wrap_exe(relative_exe_path)
wrapper_path = os.path.join(snapdir, relative_wrapper_path)
expected = ('#!/bin/sh\n'
'PATH=$SNAP/usr/bin:$SNAP/bin\n'
'\n\n'
'exec "$SNAP/test_relexepath" $*\n')
with open(wrapper_path) as wrapper_file:
wrapper_contents = wrapper_file.read()
self.assertEqual(expected, wrapper_contents)
def test_strip_one_part_only_from_3(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml(n=3)
main(['strip', 'strip1'])
self.assertFalse(
os.path.exists(
os.path.join(common.get_snapdir(), 'meta', 'snap.yaml')),
'There should not be a snap.yaml')
self.assertTrue(os.path.exists(common.get_snapdir()),
'Expected a snap directory')
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the strip1 part')
self.verify_state('strip1', parts[1]['state_dir'], 'strip')
for i in [0, 2]:
self.assertFalse(os.path.exists(parts[i]['part_dir']),
'Pulled wrong part')
self.assertFalse(os.path.exists(parts[i]['state_dir']),
'Expected for only to be a state file for build1')
def __init__(self, plugin_name, part_name, properties,
project_options, part_schema):
self.valid = False
self.code = None
self.config = {}
self._name = part_name
self._ubuntu = None
self._project_options = project_options
self.deps = []
self.stagedir = os.path.join(os.getcwd(), 'stage')
self.snapdir = os.path.join(os.getcwd(), 'snap')
parts_dir = common.get_partsdir()
self.bindir = os.path.join(parts_dir, part_name, 'bin')
self.ubuntudir = os.path.join(parts_dir, part_name, 'ubuntu')
self.statedir = os.path.join(parts_dir, part_name, 'state')
self._migrate_state_file()
try:
self._load_code(plugin_name, properties, part_schema)
except jsonschema.ValidationError as e:
raise PluginError('properties failed to load for {}: {}'.format(
part_name, e.message))
def test_build_one_part_only_from_3(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml(n=3)
build.main(['build1', ])
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the build1 part')
self.assertTrue(os.path.exists(parts[1]['state_file']),
'Expected a state file for the build1 part')
with open(parts[1]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(len(state), 1, 'Expected only one line in the state '
'file for the build1 part')
self.assertEqual(state[0], 'build', "Expected the state file for "
" build1 to be 'build'")
for i in [0, 2]:
self.assertFalse(os.path.exists(parts[i]['part_dir']),
'Pulled wrong part')
self.assertFalse(os.path.exists(parts[i]['state_file']),
'Expected for only to be a state file for build1')
def _write_wrap_exe(wrapexec, wrappath, shebang=None, args=None, cwd=None):
args = ' '.join(args) + ' $*' if args else '$*'
cwd = 'cd {}'.format(cwd) if cwd else ''
snap_dir = common.get_snapdir()
assembled_env = common.assemble_env().replace(snap_dir, '$SNAP')
replace_path = r'{}/[a-z0-9][a-z0-9+-]*/install'.format(
common.get_partsdir())
assembled_env = re.sub(replace_path, '$SNAP', assembled_env)
executable = '"{}"'.format(wrapexec)
if shebang is not None:
new_shebang = re.sub(replace_path, '$SNAP', shebang)
if new_shebang != shebang:
# If the shebang was pointing to and executable within the
# local 'parts' dir, have the wrapper script execute it
# directly, since we can't use $SNAP in the shebang itself.
executable = '"{}" "{}"'.format(new_shebang, wrapexec)
script = ('#!/bin/sh\n' +
'{}\n'.format(assembled_env) +
'{}\n'.format(cwd) +
'exec {} {}\n'.format(executable, args))
with open(wrappath, 'w+') as f:
f.write(script)
os.chmod(wrappath, 0o755)
def _write_wrap_exe(wrapexec, wrappath, shebang=None, args=None, cwd=None):
args = ' '.join(args) + ' $*' if args else '$*'
cwd = 'cd {}'.format(cwd) if cwd else ''
snap_dir = common.get_snapdir()
assembled_env = common.assemble_env().replace(snap_dir, '$SNAP_APP_PATH')
replace_path = r'{}/[a-z0-9][a-z0-9+-]*/install'.format(
common.get_partsdir())
assembled_env = re.sub(replace_path, '$SNAP_APP_PATH', assembled_env)
executable = '"{}"'.format(wrapexec)
if shebang is not None:
new_shebang = re.sub(replace_path, '$SNAP_APP_PATH', shebang)
if new_shebang != shebang:
# If the shebang was pointing to and executable within the
# local 'parts' dir, have the wrapper script execute it
# directly, since we can't use $SNAP_APP_PATH in the shebang
# itself.
executable = '"{}" "{}"'.format(new_shebang, wrapexec)
script = ('#!/bin/sh\n' + '{}\n'.format(assembled_env) +
'{}\n'.format(cwd) + 'exec {} {}\n'.format(executable, args))
with open(wrappath, 'w+') as f:
f.write(script)
os.chmod(wrappath, 0o755)
def test_strip_defaults(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
strip.main()
self.assertTrue(os.path.exists(common.get_snapdir()),
'Expected a snap directory')
self.assertTrue(
os.path.exists(
os.path.join(common.get_snapdir(), 'meta', 'package.yaml')),
'Expected a package.yaml')
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the build0 part')
self.assertTrue(os.path.exists(parts[0]['state_file']),
'Expected a state file for the build0 part')
with open(parts[0]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(
len(state), 1, 'Expected only one line in the state '
'file for the build0 part')
self.assertEqual(state[0], 'strip', "Expected the state file for "
"build0 to be 'strip'")
def test_wrap_exe_must_write_wrapper(self, mock_assemble_env):
mock_assemble_env.return_value = """\
PATH={0}/part1/install/usr/bin:{0}/part1/install/bin
""".format(common.get_partsdir())
snapdir = common.get_snapdir()
os.mkdir(snapdir)
relative_exe_path = 'test_relexepath'
open(os.path.join(snapdir, relative_exe_path), 'w').close()
# Check that the wrapper is created even if there is already a file
# with the same name.
open(os.path.join('snap', 'test_relexepath.wrapper'), 'w').close()
relative_wrapper_path = meta._wrap_exe(relative_exe_path)
wrapper_path = os.path.join(snapdir, relative_wrapper_path)
expected = ('#!/bin/sh\n'
'PATH=$SNAP/usr/bin:$SNAP/bin\n'
'\n\n'
'exec "$SNAP/test_relexepath" $*\n')
with open(wrapper_path) as wrapper_file:
wrapper_contents = wrapper_file.read()
self.assertEqual(expected, wrapper_contents)
def test_pull_one_part_only_from_3(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml(n=3)
pull.main(['pull1', ])
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the pull1 part')
self.assertTrue(os.path.exists(parts[1]['state_file']),
'Expected a state file for the pull1 part')
with open(parts[1]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(len(state), 1, 'Expected only one line in the state '
'file for the pull1 part')
self.assertEqual(state[0], 'pull', "Expected the state file for pull1 "
"to be 'pull'")
for i in [0, 2]:
self.assertFalse(os.path.exists(parts[i]['part_dir']),
'Pulled wrong part')
self.assertFalse(os.path.exists(parts[i]['state_file']),
'Expected for only to be a state file for pull1')
def test_stage_ran_twice_is_a_noop(self):
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
stage.main()
self.assertEqual(
'Pulling stage0 \n'
'Building stage0 \n'
'Staging stage0 \n',
fake_logger.output)
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the build0 part')
self.verify_state('build0', parts[0]['state_dir'], 'stage')
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
stage.main()
self.assertEqual(
'Skipping pull stage0 (already ran)\n'
'Skipping build stage0 (already ran)\n'
'Skipping stage stage0 (already ran)\n',
fake_logger.output)
def test_clean_all(self):
self.make_snapcraft_yaml(n=3)
clean.main()
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_clean_all_when_all_parts_specified(self):
self.make_snapcraft_yaml(n=3)
clean.main(['clean0', 'clean1', 'clean2'])
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_clean_all_when_all_parts_specified(self):
self.make_snapcraft_yaml(n=3)
clean.main(['clean0', 'clean1', 'clean2'])
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_clean_all(self):
self.make_snapcraft_yaml(n=3)
clean.main()
self.assertFalse(os.path.exists(common.get_partsdir()))
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_partial_clean(self):
class args:
parts = ['part1']
cmds.clean(args())
self.mock_exists.assert_has_calls([
mock.call(common.get_partsdir()),
mock.call().__bool__(),
mock.call(common.get_snapdir()),
mock.call().__bool__(),
])
self.mock_rmtree.assert_has_calls([
mock.call(common.get_snapdir()),
])
self.mock_rmdir.assert_called_once_with(common.get_partsdir())
self.assertEqual(self.clean_calls, ['part1'])
def clean(args):
config = _load_config()
for part in config.all_parts:
logger.info("Cleaning up for part %r", part.name)
if os.path.exists(part.partdir):
shutil.rmtree(part.partdir)
# parts dir does not contain only generated code.
if os.path.exists(common.get_partsdir()) and not os.listdir(common.get_partsdir()):
os.rmdir(common.get_partsdir())
logger.info("Cleaning up staging area")
if os.path.exists(common.get_stagedir()):
shutil.rmtree(common.get_stagedir())
logger.info("Cleaning up snapping area")
if os.path.exists(common.get_snapdir()):
shutil.rmtree(common.get_snapdir())
def clean(args):
config = _load_config()
for part in config.all_parts:
logger.info('Cleaning up for part %r', part.name)
if os.path.exists(part.partdir):
shutil.rmtree(part.partdir)
# parts dir does not contain only generated code.
if (os.path.exists(common.get_partsdir()) and
not os.listdir(common.get_partsdir())):
os.rmdir(common.get_partsdir())
logger.info('Cleaning up staging area')
if os.path.exists(common.get_stagedir()):
shutil.rmtree(common.get_stagedir())
logger.info('Cleaning up snapping area')
if os.path.exists(common.get_snapdir()):
shutil.rmtree(common.get_snapdir())
def test_pull_defaults(self):
parts = self.make_snapcraft_yaml()
main(['pull'])
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the pull0 part')
self.verify_state('pull0', parts[0]['state_dir'], 'pull')
def test_clean_all_when_all_parts_specified(self):
class args:
parts = ["part1", "part2", "part3"]
cmds.clean(args())
self.mock_exists.assert_has_calls(
[
mock.call(common.get_partsdir()),
mock.call().__bool__(),
mock.call(common.get_stagedir()),
mock.call().__bool__(),
mock.call(common.get_snapdir()),
mock.call().__bool__(),
]
)
self.mock_rmtree.assert_has_calls([mock.call(common.get_stagedir()), mock.call(common.get_snapdir())])
self.mock_rmdir.assert_called_once_with(common.get_partsdir())
self.assertEqual(self.clean_calls, ["part1", "part2", "part3"])
def test_build_defaults(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
main(['build'])
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the build0 part')
self.verify_state('build0', parts[0]['state_dir'], 'build')
def test_local_plugin_not_removed(self):
self.make_snapcraft_yaml(n=3)
local_plugin = os.path.join(common.get_local_plugindir(), "foo.py")
os.makedirs(os.path.dirname(local_plugin))
open(local_plugin, "w").close()
main(["clean"])
self.assertFalse(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
self.assertTrue(os.path.exists(common.get_partsdir()))
self.assertTrue(os.path.isfile(local_plugin))
def make_snapcraft_yaml(self, n=1):
parts = '\n'.join([self.yaml_part.format(i) for i in range(n)])
super().make_snapcraft_yaml(self.yaml_template.format(parts=parts))
parts = []
for i in range(n):
part_dir = os.path.join(common.get_partsdir(), 'build{}'.format(i))
state_dir = os.path.join(part_dir, 'state')
parts.append({
'part_dir': part_dir,
'state_dir': state_dir,
})
return parts
def __init__(self, name, options):
self.name = name
self.build_packages = []
self.stage_packages = []
with contextlib.suppress(AttributeError):
self.stage_packages = options.stage_packages
with contextlib.suppress(AttributeError):
self.build_packages = options.build_packages
self.options = options
self.partdir = os.path.join(common.get_partsdir(), self.name)
self.sourcedir = os.path.join(self.partdir, "src")
self.builddir = os.path.join(self.partdir, "build")
self.installdir = os.path.join(self.partdir, "install")
def _write_wrap_exe(wrapexec, wrappath, args=[], cwd=None):
args = ' '.join(args) + ' $*' if args else '$*'
cwd = 'cd {}'.format(cwd) if cwd else ''
snap_dir = common.get_snapdir()
assembled_env = common.assemble_env().replace(snap_dir, '$SNAP_APP_PATH')
replace_path = r'{}/.*/install'.format(common.get_partsdir())
assembled_env = re.sub(replace_path, '$SNAP_APP_PATH', assembled_env)
script = ('#!/bin/sh\n' + '{}\n'.format(assembled_env) +
'{}\n'.format(cwd) + 'exec "{}" {}\n'.format(wrapexec, args))
with open(wrappath, 'w+') as f:
f.write(script)
os.chmod(wrappath, 0o755)
def make_snapcraft_yaml(self, n=1):
parts = '\n'.join([self.yaml_part.format(i) for i in range(n)])
super().make_snapcraft_yaml(self.yaml_template.format(parts=parts))
open('icon.png', 'w').close()
parts = []
for i in range(n):
part_dir = os.path.join(common.get_partsdir(), 'pull{}'.format(i))
state_file = os.path.join(part_dir, 'state')
parts.append({
'part_dir': part_dir,
'state_file': state_file,
})
return parts
def __init__(self, name, options):
self.name = name
self.build_packages = []
self.stage_packages = []
with contextlib.suppress(AttributeError):
self.stage_packages = options.stage_packages
with contextlib.suppress(AttributeError):
self.build_packages = options.build_packages
self.options = options
self.partdir = os.path.join(common.get_partsdir(), self.name)
self.sourcedir = os.path.join(self.partdir, 'src')
self.builddir = os.path.join(self.partdir, 'build')
self.installdir = os.path.join(self.partdir, 'install')
def make_snapcraft_yaml(self, n=1):
parts = '\n'.join([self.yaml_part.format(i) for i in range(n)])
super().make_snapcraft_yaml(self.yaml_template.format(parts=parts))
open('icon.png', 'w').close()
parts = []
for i in range(n):
part_dir = os.path.join(common.get_partsdir(), 'strip{}'.format(i))
state_file = os.path.join(part_dir, 'state')
parts.append({
'part_dir': part_dir,
'state_file': state_file,
})
return parts
def test_everything_is_clean(self):
self.mock_exists.return_value = False
self.mock_listdir.side_effect = FileNotFoundError()
class args:
parts = []
cmds.clean(args())
self.mock_exists.assert_has_calls(
[mock.call(common.get_partsdir()), mock.call(common.get_stagedir()), mock.call(common.get_snapdir())]
)
self.assertFalse(self.mock_rmdir.called)
self.assertFalse(self.mock_rmtree.called)
self.assertEqual(self.clean_calls, ["part1", "part2", "part3"])
def test_everything_is_clean(self):
self.mock_exists.return_value = False
self.mock_listdir.side_effect = FileNotFoundError()
cmds.clean({})
self.mock_exists.assert_has_calls([
mock.call('partdir1'),
mock.call('partdir2'),
mock.call('partdir3'),
mock.call(common.get_partsdir()),
mock.call(common.get_stagedir()),
mock.call(common.get_snapdir()),
])
self.assertFalse(self.mock_rmdir.called)
self.assertFalse(self.mock_rmtree.called)
def __init__(self, plugin_name, part_name, properties):
self.valid = False
self.code = None
self.config = {}
self._name = part_name
self.deps = []
parts_dir = common.get_partsdir()
self.ubuntudir = os.path.join(parts_dir, part_name, 'ubuntu')
self.stagedir = os.path.join(os.getcwd(), 'stage')
self.snapdir = os.path.join(os.getcwd(), 'snap')
self.statefile = os.path.join(parts_dir, part_name, 'state')
try:
self._load_code(plugin_name, properties)
except jsonschema.ValidationError as e:
raise PluginError('properties failed to load for {}: {}'.format(
part_name, e.message))
def test_no_parts_defined(self):
self.fake_config.all_parts = []
self.mock_load_config.return_value = self.fake_config
cmds.clean({})
self.mock_exists.assert_has_calls([
mock.call(common.get_stagedir()),
mock.call().__bool__(),
mock.call(common.get_snapdir()),
mock.call().__bool__(),
])
self.mock_rmtree.assert_has_calls([
mock.call(common.get_stagedir()),
mock.call(common.get_snapdir()),
])
self.mock_rmdir.assert_called_once_with(common.get_partsdir())
def test_pull_defaults(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
pull.main()
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the pull0 part')
self.assertTrue(os.path.exists(parts[0]['state_file']),
'Expected a state file for the pull0 part')
with open(parts[0]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(len(state), 1, 'Expected only one line in the state '
'file for the pull0 part')
self.assertEqual(state[0], 'pull', "Expected the state file for pull0 "
"to be 'pull'")
def test_partial_clean(self):
parts = self.make_snapcraft_yaml(n=3)
clean.main(['clean0', 'clean2', ])
for i in [0, 2]:
self.assertFalse(
os.path.exists(parts[i]['part_dir']),
'Expected for {!r} to be wiped'.format(parts[i]['part_dir']))
self.assertFalse(
os.path.exists(parts[i]['state_file']),
'Expected for {!r} to be wiped'.format(parts[i]['state_file']))
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the clean1 part')
self.assertTrue(os.path.exists(parts[1]['state_file']),
'Expected a state file for the clean1 part')
self.assertTrue(os.path.exists(common.get_partsdir()))
self.assertTrue(os.path.exists(common.get_stagedir()))
self.assertFalse(os.path.exists(common.get_snapdir()))
def test_strip_ran_twice_is_a_noop(self):
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml()
strip.main()
self.assertEqual(
'Pulling strip0 \n'
'Building strip0 \n'
'Staging strip0 \n'
'Stripping strip0 \n', fake_logger.output)
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[0]['part_dir']),
'Expected a part directory for the build0 part')
self.assertTrue(os.path.exists(parts[0]['state_file']),
'Expected a state file for the build0 part')
with open(parts[0]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(
len(state), 1, 'Expected only one line in the state '
'file for the build0 part')
self.assertEqual(state[0], 'strip', "Expected the state file for "
"build0 to be 'strip'")
fake_logger = fixtures.FakeLogger(level=logging.INFO)
self.useFixture(fake_logger)
strip.main()
self.assertEqual(
'Skipping pull strip0 (already ran)\n'
'Skipping build strip0 (already ran)\n'
'Skipping stage strip0 (already ran)\n'
'Skipping strip strip0 (already ran)\n', fake_logger.output)
def make_snapcraft_yaml(self, n=1, create=True):
parts = '\n'.join([self.yaml_part.format(i) for i in range(n)])
super().make_snapcraft_yaml(self.yaml_template.format(parts=parts))
open('icon.png', 'w').close()
parts = []
for i in range(n):
part_dir = os.path.join(common.get_partsdir(), 'clean{}'.format(i))
state_file = os.path.join(part_dir, 'state')
parts.append({
'part_dir': part_dir,
'state_file': state_file,
})
if create:
os.makedirs(part_dir)
open(state_file, 'w').close()
if create:
os.makedirs(common.get_stagedir())
os.makedirs(common.get_snapdir())
return parts
def test_strip_one_part_only_from_3(self):
fake_logger = fixtures.FakeLogger(level=logging.ERROR)
self.useFixture(fake_logger)
parts = self.make_snapcraft_yaml(n=3)
strip.main([
'strip1',
])
self.assertFalse(
os.path.exists(
os.path.join(common.get_snapdir(), 'meta', 'package.yaml')),
'There should not be a package.yaml')
self.assertTrue(os.path.exists(common.get_snapdir()),
'Expected a snap directory')
self.assertTrue(os.path.exists(common.get_stagedir()),
'Expected a stage directory')
self.assertTrue(os.path.exists(common.get_partsdir()),
'Expected a parts directory')
self.assertTrue(os.path.exists(parts[1]['part_dir']),
'Expected a part directory for the strip1 part')
self.assertTrue(os.path.exists(parts[1]['state_file']),
'Expected a state file for the strip1 part')
with open(parts[1]['state_file']) as sf:
state = sf.readlines()
self.assertEqual(
len(state), 1, 'Expected only one line in the state '
'file for the strip1 part')
self.assertEqual(
state[0], 'strip', "Expected the state file for "
" strip1 to be 'strip'")
for i in [0, 2]:
self.assertFalse(os.path.exists(parts[i]['part_dir']),
'Pulled wrong part')
self.assertFalse(
os.path.exists(parts[i]['state_file']),
'Expected for only to be a state file for build1')
def test_snap_shebangs_extracted(self):
"""Shebangs pointing to the snap's install dir get extracted.
If the exe has a shebang that points to the snap's install dir,
the wrapper script will execute it directly rather than relying
on the shebang.
The shebang needs to be an absolute path, and we don't know
in which directory the snap will be installed. Executing
it in the wrapper script allows us to use the $SNAP environment
variable.
"""
snapdir = common.get_snapdir()
partsdir = common.get_partsdir()
os.mkdir(snapdir)
relative_exe_path = 'test_relexepath'
shebang_path = os.path.join(partsdir, 'testsnap', 'install',
'snap_exe')
exe_contents = '#!{}\n'.format(shebang_path)
with open(os.path.join(snapdir, relative_exe_path), 'w') as exe:
exe.write(exe_contents)
relative_wrapper_path = meta._wrap_exe(relative_exe_path)
wrapper_path = os.path.join(snapdir, relative_wrapper_path)
expected = ('#!/bin/sh\n'
'\n\n'
'exec "$SNAP/snap_exe"'
' "$SNAP/test_relexepath" $*\n')
with open(wrapper_path) as wrapper_file:
wrapper_contents = wrapper_file.read()
self.assertEqual(expected, wrapper_contents)
with open(os.path.join(snapdir, relative_exe_path), 'r') as exe:
# The shebang wasn't changed, since we don't know what the
# path will be on the installed system.
self.assertEqual(exe_contents, exe.read())
def make_snapcraft_yaml(self, n=1):
super().make_snapcraft_yaml(self.yaml_template)
self.state_file = os.path.join(common.get_partsdir(), 'part1', 'state')