def test_pull_is_dirty_if_target_arch_changes( self, mock_install_build_snaps, mock_install_build_packages, mock_enable_cross_compilation, ): # Set the option to error on dirty/outdated steps with snapcraft.config.CLIConfig() as cli_config: cli_config.set_outdated_step_action( snapcraft.config.OutdatedStepAction.ERROR ) mock_install_build_packages.return_value = [] project_config = self.make_snapcraft_project( textwrap.dedent( """\ parts: part1: plugin: nil """ ) ) project = Project( snapcraft_yaml_file_path=self.snapcraft_yaml_file_path, target_deb_arch="amd64", ) project_config = project_loader.load_config(project) # Pull it with amd64 lifecycle.execute(steps.PULL, project_config) # Reset logging since we only care about the following self.fake_logger = fixtures.FakeLogger(level=logging.INFO) self.useFixture(self.fake_logger) project = Project( snapcraft_yaml_file_path=self.snapcraft_yaml_file_path, target_deb_arch="armhf", ) project_config = project_loader.load_config(project) # Pull it again with armhf. Should catch that the part needs to be # re-pulled due to the change in target architecture and raise an # error. raised = self.assertRaises( errors.StepOutdatedError, lifecycle.execute, steps.PULL, project_config ) self.assertThat( self.fake_logger.output, Contains("Setting target machine to 'armhf'") ) self.assertThat(raised.step, Equals(steps.PULL)) self.assertThat(raised.part, Equals("part1")) self.assertThat( raised.report, Equals("The 'deb_arch' project option appears to have changed.\n"), )
def test_plugs_as_properties_should_fail(self): self.data += ' plugs: [plug1]' self.make_snapcraft_yaml(self.data) with self.assertRaises(SystemExit): project_loader.load_config() expected_message = self.expected_message_template.format('plugs') self.assertIn(expected_message, self.fake_logger.output)
def test_pull_is_dirty_if_target_arch_changes( self, mock_install_build_packages, mock_enable_cross_compilation ): mock_install_build_packages.return_value = [] project_config = self.make_snapcraft_project( textwrap.dedent( """\ parts: part1: plugin: nil """ ) ) project = Project( snapcraft_yaml_file_path=self.snapcraft_yaml_file_path, target_deb_arch="amd64", ) project_config = project_loader.load_config(project) # Pull it with amd64 lifecycle.execute(steps.PULL, project_config) # Reset logging since we only care about the following self.fake_logger = fixtures.FakeLogger(level=logging.INFO) self.useFixture(self.fake_logger) project = Project( snapcraft_yaml_file_path=self.snapcraft_yaml_file_path, target_deb_arch="armhf", ) project_config = project_loader.load_config(project) # Pull it again with armhf. Should catch that the part needs to be # re-pulled due to the change in target architecture and raise an # error. raised = self.assertRaises( errors.StepOutdatedError, lifecycle.execute, steps.PULL, project_config ) self.assertThat( self.fake_logger.output, Equals("Setting target machine to 'armhf'\n") ) self.assertThat(raised.step, Equals(steps.PULL)) self.assertThat(raised.part, Equals("part1")) self.assertThat( raised.report, Equals("The 'deb_arch' project option appears to have changed.\n"), )
def clean(project_options, parts, step=None): # step defaults to None because that's how it comes from docopt when it's # not set. if not step: step = steps.PULL if not parts and step == steps.PULL: _cleanup_common_directories_for_step(step, project_options) return config = project_loader.load_config(project_options) if not parts and step <= steps.PRIME: # If we've been asked to clean stage or prime without being given # specific parts, just blow away those directories instead of # doing it per part (it would just be a waste of time). _cleanup_common_directories_for_step( step, project_options, parts=config.all_parts ) # No need to continue if that's all that was required if step >= steps.STAGE: return if parts: config.parts.validate(parts) else: parts = [part.name for part in config.all_parts] staged_state = config.get_project_state(steps.STAGE) primed_state = config.get_project_state(steps.PRIME) _clean_parts(parts, step, config, staged_state, primed_state) _cleanup_common_directories(config, project_options)
def refresh(debug, **kwargs): """Refresh an existing LXD container. \b Examples: snapcraft refresh This will take care of updating the apt package cache, upgrading packages as needed as well as refreshing snaps. """ build_environment = env.BuilderEnvironmentConfig() if build_environment.is_host: raise errors.SnapcraftEnvironmentError( "The 'refresh' command only applies to LXD containers but " "SNAPCRAFT_BUILD_ENVIRONMENT is not set or set to host.\n" "Maybe you meant to update the parts cache instead? " "You can do that with the following command:\n\n" "snapcraft update") project = get_project(**kwargs, debug=debug) config = project_loader.load_config(project) lxd.Project( project_options=project, output=None, source=os.path.curdir, metadata=config.get_metadata(), ).refresh()
def make_snapcraft_project(self, snapcraft_yaml, project_kwargs=None): snapcraft_yaml_file_path = self.make_snapcraft_yaml(snapcraft_yaml) if project_kwargs is None: project_kwargs = dict() project = _Project(snapcraft_yaml_file_path=snapcraft_yaml_file_path, **project_kwargs) return project_loader.load_config(project)
def clean(project_options, parts, step=None): # step defaults to None because that's how it comes from docopt when it's # not set. if not step: step = steps.PULL if not parts and step == steps.PULL: _cleanup_common_directories_for_step(step, project_options) return config = project_loader.load_config(project_options) if not parts and step <= steps.PRIME: # If we've been asked to clean stage or prime without being given # specific parts, just blow away those directories instead of # doing it per part (it would just be a waste of time). _cleanup_common_directories_for_step( step, project_options, parts=config.all_parts ) # No need to continue if that's all that was required if step >= steps.STAGE: return if parts: config.parts.validate(parts) else: parts = [part.name for part in config.all_parts] staged_state = config.get_project_state(steps.STAGE) primed_state = config.get_project_state(steps.PRIME) _clean_parts(parts, step, config, staged_state, primed_state) _cleanup_common_directories(config, project_options)
def make_snapcraft_project(self, common_id): yaml = textwrap.dedent( """\ name: test base: core18 version: "1.0" summary: test description: test confinement: strict grade: stable adopt-info: part apps: test-app: command: echo common-id: {common_id} parts: part: plugin: nil parse-info: ["1.metainfo.xml", "2.metainfo.xml"] """ ) yaml_path = self.make_snapcraft_yaml(yaml.format(common_id=common_id)) project = Project(snapcraft_yaml_file_path=yaml_path) return project_loader.load_config(project)
def generate_meta_yaml( self, *, build=False, actual_prime_dir=None, snapcraft_yaml_file_path=None ): if snapcraft_yaml_file_path is None: snapcraft_yaml_file_path = self.snapcraft_yaml_file_path os.makedirs("snap", exist_ok=True) with open(snapcraft_yaml_file_path, "w") as f: f.write(yaml_utils.dump(self.config_data)) self.project = Project(snapcraft_yaml_file_path=snapcraft_yaml_file_path) if actual_prime_dir is not None: self.project._prime_dir = actual_prime_dir self.meta_dir = os.path.join(self.project.prime_dir, "meta") self.hooks_dir = os.path.join(self.meta_dir, "hooks") self.snap_yaml = os.path.join(self.meta_dir, "snap.yaml") self.config = project_loader.load_config(project=self.project) if build: for part in self.config.parts.all_parts: part.pull() part.build() part.stage() part.prime() _snap_packaging.create_snap_packaging(self.config) self.assertTrue(os.path.exists(self.snap_yaml), "snap.yaml was not created") with open(self.snap_yaml) as f: return yaml_utils.load(f)
def refresh(debug, **kwargs): """Refresh an existing LXD container. \b Examples: snapcraft refresh This will take care of updating the apt package cache, upgrading packages as needed as well as refreshing snaps. """ container_config = env.get_container_config() if not container_config.use_container: raise errors.SnapcraftEnvironmentError( "The 'refresh' command only applies to LXD containers but " "SNAPCRAFT_CONTAINER_BUILDS is not set or 0.\n" "Maybe you meant to update the parts cache instead? " "You can do that with the following command:\n\n" "snapcraft update") project_options = get_project_options(**kwargs, debug=debug) config = project_loader.load_config(project_options) lxd.Project(project_options=project_options, remote=container_config.remote, output=None, source=os.path.curdir, metadata=config.get_metadata()).refresh()
def refresh(debug, **kwargs): """Refresh an existing LXD container. \b Examples: snapcraft refresh This will take care of updating the apt package cache, upgrading packages as needed as well as refreshing snaps. """ build_environment = env.BuilderEnvironmentConfig() if build_environment.is_host: raise errors.SnapcraftEnvironmentError( "The 'refresh' command only applies to LXD containers but " "SNAPCRAFT_BUILD_ENVIRONMENT is not set or set to host.\n" "Maybe you meant to update the parts cache instead? " "You can do that with the following command:\n\n" "snapcraft update" ) project = get_project(**kwargs, debug=debug) config = project_loader.load_config(project) lxd.Project( project_options=project, output=None, source=os.path.curdir, metadata=config.get_metadata(), ).refresh()
def clean(project_options, parts, step=None): # step defaults to None because that's how it comes from docopt when it's # not set. if not step: step = 'pull' if not parts and step == 'pull': _cleanup_common_directories_for_step(step, project_options) return config = project_loader.load_config() if not parts and (step == 'stage' or step == 'prime'): # If we've been asked to clean stage or prime without being given # specific parts, just blow away those directories instead of # doing it per part. _cleanup_common_directories_for_step(step, project_options, parts=config.all_parts) return if parts: config.parts.validate(parts) else: parts = [part.name for part in config.all_parts] staged_state = config.get_project_state('stage') primed_state = config.get_project_state('prime') _clean_parts(parts, step, config, staged_state, primed_state) _cleanup_common_directories(config, project_options)
def cleanbuild(remote, debug, **kwargs): """Create a snap using a clean environment managed by a build provider. \b Examples: snapcraft cleanbuild The cleanbuild command requires a properly setup lxd environment that can connect to external networks. Refer to the "Ubuntu Desktop and Ubuntu Server" section on https://linuxcontainers.org/lxd/getting-started-cli to get started. If using a remote, a prior setup is required which is described on: https://linuxcontainers.org/lxd/getting-started-cli/#multiple-hosts """ project = get_project(**kwargs, debug=debug) project_config = project_loader.load_config(project) # cleanbuild is a special snow flake, while all the other commands # would work with the host as the build_provider it makes little # sense in this scenario. build_environment = env.BuilderEnvironmentConfig( default="lxd", additional_providers=["multipass"] ) lifecycle.cleanbuild( project=project, project_config=project_config, echoer=echo, remote=remote, build_environment=build_environment, )
def clean(parts, step_name, **kwargs): """Remove content - cleans downloads, builds or install artifacts. \b Examples: snapcraft clean snapcraft clean my-part --step build """ try: project = get_project(**kwargs) except YamlValidationError: # We need to be able to clean invalid projects too. project = get_project(skip_snapcraft_yaml=True, **kwargs) build_environment = env.BuilderEnvironmentConfig() step = None if step_name: if step_name == "strip": echo.warning( "DEPRECATED: Use `prime` instead of `strip` as the step to clean" ) step_name = "prime" step = steps.get_step_by_name(step_name) if build_environment.is_host: lifecycle.clean(project, parts, step) else: project_config = project_loader.load_config(project) lxd.Project( project_options=project, output=None, source=os.path.curdir, metadata=project_config.get_metadata(), ).clean(parts, step)
def get_project_config(snapcraft_yaml_content): snapcraft_yaml_path = pathlib.Path("Snapcraft.yaml") with snapcraft_yaml_path.open("w") as snapcraft_yaml_file: print(snapcraft_yaml_content, file=snapcraft_yaml_file) project = Project(snapcraft_yaml_file_path=snapcraft_yaml_path.as_posix()) return project_loader.load_config(project)
def make_snapcraft_project(self, snapcraft_yaml, project_kwargs=None): snapcraft_yaml_file_path = self.make_snapcraft_yaml(snapcraft_yaml) if project_kwargs is None: project_kwargs = dict() project = _Project( snapcraft_yaml_file_path=snapcraft_yaml_file_path, **project_kwargs ) return project_loader.load_config(project)
def _execute( # noqa: C901 step: steps.Step, parts: str, pack_project: bool = False, output: str = None, shell: bool = False, shell_after: bool = False, destructive_mode: bool = False, **kwargs) -> "Project": # fmt: on provider = "host" if destructive_mode else None build_environment = env.BuilderEnvironmentConfig(force_provider=provider) project = get_project(is_managed_host=build_environment.is_managed_host, **kwargs) conduct_project_sanity_check(project) if build_environment.is_managed_host or build_environment.is_host: project_config = project_loader.load_config(project) lifecycle.execute(step, project_config, parts) if pack_project: _pack(project.prime_dir, output=output) else: build_provider_class = build_providers.get_provider_for( build_environment.provider) echo.info("Launching a VM.") with build_provider_class(project=project, echoer=echo) as instance: instance.mount_project() try: if shell: # shell means we want to do everything right up to the previous # step and then go into a shell instead of the requested step. # the "snap" target is a special snowflake that has not made its # way to be a proper step. previous_step = None if pack_project: previous_step = steps.PRIME elif step > steps.PULL: previous_step = step.previous_step() # steps.PULL is the first step, so we would directly shell into it. if previous_step: instance.execute_step(previous_step) elif pack_project: instance.pack_project(output=output) else: instance.execute_step(step) except Exception: if project.debug: instance.shell() else: echo.warning( "Run the same command again with --debug to shell into the environment " "if you wish to introspect this failure.") raise else: if shell or shell_after: instance.shell() return project
def make_snapcraft_project(self, *, confinement: str): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path) snapcraft_yaml.data["confinement"] = confinement snapcraft_yaml.update_part("test-part", dict(plugin="nil")) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path) return project_loader.load_config(project)
def test_part_order_consistency(self): """Test that parts are always processed in the same order.""" self.make_snapcraft_yaml(self.contents) config = project_loader.load_config() self.assertThat(config.all_parts, HasLength(len(self.expected_order))) for part, expected_name in zip(config.all_parts, self.expected_order): self.expectThat(part.name, Equals(expected_name))
def make_snapcraft_project(self, parts): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path) snapcraft_yaml.update_part("part1", dict(plugin="nil")) for part_name, part in parts: snapcraft_yaml.update_part(part_name, part) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path) return project_loader.load_config(project)
def make_snapcraft_project(self, apps): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path) snapcraft_yaml.update_part("part1", dict(plugin="nil")) for app_name, app in apps: snapcraft_yaml.update_app(app_name, app) self.useFixture(snapcraft_yaml) p = project.Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path) return load_config(p)
def get_project_config(snapcraft_yaml_content, target_deb_arch=None): snapcraft_yaml_path = pathlib.Path("Snapcraft.yaml") with snapcraft_yaml_path.open("w") as snapcraft_yaml_file: print(snapcraft_yaml_content, file=snapcraft_yaml_file) snapcraft_project = project.Project( snapcraft_yaml_file_path=snapcraft_yaml_path.as_posix(), target_deb_arch=target_deb_arch, ) return load_config(snapcraft_project)
def make_snapcraft_project(self, *, confinement: str): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path) snapcraft_yaml.data["confinement"] = confinement snapcraft_yaml.update_part("test-part", dict(plugin="nil")) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path ) return project_loader.load_config(project)
def test_load_with_dummy_repo(self, os_release_mock): self.make_snapcraft_yaml(dedent("""\ name: test version: "1" summary: test description: test confinement: strict parts: part1: source: https://github.com/snapcore/snapcraft.git plugin: python stage-packages: [fswebcam] snap: [foo] """)) # Ensure the dummy repo returns an empty set for required # build tools. project_loader.load_config()
def _execute(step: steps.Step, parts, **kwargs): project = get_project(**kwargs) project_config = project_loader.load_config(project) build_environment = env.BuilderEnvironmentConfig() if build_environment.is_host: lifecycle.execute(step, project_config, parts) else: # containerbuild takes a snapcraft command name, not a step lifecycle.containerbuild(step.name, project_config, parts) return project
def make_snapcraft_project(self, parts): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path) snapcraft_yaml.update_part("part1", dict(plugin="nil")) for part_name, part in parts: snapcraft_yaml.update_part(part_name, part) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path ) return project_loader.load_config(project)
def test_load_with_dummy_repo(self, os_release_mock): self.make_snapcraft_yaml( dedent("""\ name: test version: "1" summary: test description: test confinement: strict parts: part1: source: https://github.com/snapcore/snapcraft.git plugin: python stage-packages: [fswebcam] snap: [foo] """)) # Ensure the dummy repo returns an empty set for required # build tools. project_loader.load_config()
def test_slash_warning(self, mock_loadPlugin): fake_logger = fixtures.FakeLogger(level=logging.WARN) self.useFixture(fake_logger) self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part/1: plugin: go stage-packages: [fswebcam] """) project_loader.load_config() self.assertThat(fake_logger.output, Contains( 'DEPRECATED: Found a "/" in the name of the {!r} part'.format( 'part/1')))
def _get_snap_packaging(self, **yaml_args): if "parts" not in yaml_args: yaml_args["parts"] = dict(part1=dict(plugin="nil")) snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path, **yaml_args) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path) config = load_config(project) return _SnapPackaging(project_config=config, extracted_metadata=None)
def update(ctx, **kwargs): """Updates the parts listing from the cloud.""" # Update in the container so that it will use the parts at build time build_environment = env.BuilderEnvironmentConfig() if not build_environment.is_host: project = get_project(**kwargs) project_config = project_loader.load_config(project) lifecycle.containerbuild("update", project_config) # Parts can be defined and searched from any folder on the host, so # regardless of using containers we always update these as well remote_parts.update()
def test_snap_deprecation(self, mock_loadPlugin): """Test that using the 'snap' keyword results in a warning.""" fake_logger = fixtures.FakeLogger(level=logging.WARN) self.useFixture(fake_logger) self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part1: plugin: go stage-packages: [fswebcam] snap: [foo] """) project_loader.load_config() self.assertThat(fake_logger.output, Contains(deprecations._deprecation_message('dn1')))
def cleanbuild(*, project, echoer, build_environment, remote='') -> None: config = project_loader.load_config(project) tar_filename = _create_tar_file(project.info.name) if build_environment.is_lxd: _deprecated_cleanbuild(project, remote, config, tar_filename) return build_provider_class = build_providers.get_provider_for('multipass') with build_provider_class(project=project, echoer=echoer) as instance: instance.provision_project(tar_filename) instance.build_project() instance.retrieve_snap()
def refresh(project): series = storeapi.constants.DEFAULT_SERIES project_config = project_loader.load_config(project) snap_name = project_config.data["name"] logger.info('Refreshing credentials to push and release "{}" snaps ' "to edge channel in series {}".format(snap_name, series)) packages = [{"name": snap_name, "series": series}] channels = ["edge"] _acquire_and_encrypt_credentials(packages, channels) logger.info("Done. Please commit the changes to `{}` file.".format( ENCRYPTED_CONFIG_FILENAME))
def test_create_gadget_meta_with_missing_gadget_yaml_raises_error(self): self.config_data['type'] = 'gadget' os.makedirs('snap', exist_ok=True) with open(os.path.join('snap', 'snapcraft.yaml'), 'w') as f: f.write(yaml.dump(self.config_data)) config = project_loader.load_config() self.assertRaises(errors.MissingGadgetError, _snap_packaging.create_snap_packaging, self.config_data, config.parts, self.project_options, 'dummy')
def test_snap_deprecation(self): """Test that using the 'snap' keyword results in a warning.""" fake_logger = fixtures.FakeLogger(level=logging.WARN) self.useFixture(fake_logger) self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part1: plugin: go stage-packages: [fswebcam] snap: [foo] """) project_loader.load_config() self.assertThat(fake_logger.output, Contains(deprecations._deprecation_message('dn1')))
def test_slash_warning(self): fake_logger = fixtures.FakeLogger(level=logging.WARN) self.useFixture(fake_logger) self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part/1: plugin: go stage-packages: [fswebcam] """) project_loader.load_config() self.assertThat( fake_logger.output, Contains( 'DEPRECATED: Found a "/" in the name of the {!r} part'.format( 'part/1')))
def refresh(): series = storeapi.constants.DEFAULT_SERIES project_config = project_loader.load_config() snap_name = project_config.data['name'] logger.info('Refreshing credentials to push and release "{}" snaps ' 'to edge channel in series {}'.format(snap_name, series)) packages = [{'name': snap_name, 'series': series}] channels = ['edge'] _acquire_and_encrypt_credentials(packages, channels) logger.info('Done. Please commit the changes to `{}` file.'.format( ENCRYPTED_CONFIG_FILENAME))
def test_get_parts_none(self): self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part1: plugin: go stage-packages: [fswebcam] """) config = project_loader.load_config(None) self.assertThat(config.parts.get_part('not-a-part'), Equals(None))
def test_get_parts_none(self, mock_loadPlugin): self.make_snapcraft_yaml("""name: test version: "1" summary: test description: test confinement: strict parts: part1: plugin: go stage-packages: [fswebcam] """) config = project_loader.load_config(None) self.assertEqual(None, config.parts.get_part('not-a-part'))
def cleanbuild(project_options, remote=''): if remote and not lxd._remote_is_valid(remote): raise errors.InvalidContainerRemoteError(remote) config = project_loader.load_config(project_options) tar_filename = '{}_{}_source.tar.bz2'.format(config.data['name'], config.data['version']) with tarfile.open(tar_filename, 'w:bz2') as t: t.add(os.path.curdir, filter=_create_tar_filter(tar_filename)) lxd.Cleanbuilder(source=tar_filename, project_options=project_options, metadata=config.get_metadata(), remote=remote).execute()
def test_non_prime_and_no_version(self): snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path, version=None) snapcraft_yaml.data["adopt-info"] = "test-part" snapcraft_yaml.update_part( "test-part", {"plugin": "nil", "override-build": "snapcraftctl set-version 1.0"}, ) self.useFixture(snapcraft_yaml) project = Project( snapcraft_yaml_file_path=snapcraft_yaml.snapcraft_yaml_file_path ) project_config = project_loader.load_config(project) # This should not fail lifecycle.execute(steps.PULL, project_config)
def enable(project): series = storeapi.constants.DEFAULT_SERIES project_config = project_loader.load_config(project) snap_name = project_config.data["name"] logger.info( "Enabling Travis testbeds to push and release {!r} snaps " "to edge channel in series {!r}".format(snap_name, series) ) packages = [{"name": snap_name, "series": series}] channels = ["edge"] _acquire_and_encrypt_credentials(packages, channels) logger.info( 'Configuring "deploy" phase to build and release the snap in the ' "Store." ) with open(TRAVIS_CONFIG_FILENAME, "r+") as fd: travis_conf = yaml.safe_load(fd) # Enable 'sudo' capability and 'docker' service. travis_conf["sudo"] = "required" services = travis_conf.setdefault("services", []) if "docker" not in services: services.append("docker") # Add a 'deploy' section with 'script' provider for building and # release the snap within a xenial docker container. travis_conf["deploy"] = { "skip_cleanup": True, "provider": "script", "script": ( "docker run -v $(pwd):$(pwd) -t snapcore/snapcraft sh -c " '"apt update -qq && cd $(pwd) && ' 'snapcraft && snapcraft push *.snap --release edge"' ), "on": {"branch": "master"}, } fd.seek(0) yaml.dump(travis_conf, fd, default_flow_style=False) logger.info( "Done. Now you just have to review and commit changes in your " "Travis project (`{}`).\n" "Also make sure you add the new `{}` file.".format( TRAVIS_CONFIG_FILENAME, ENCRYPTED_CONFIG_FILENAME ) )
def refresh(project): series = storeapi.constants.DEFAULT_SERIES project_config = project_loader.load_config(project) snap_name = project_config.data["name"] logger.info( 'Refreshing credentials to push and release "{}" snaps ' "to edge channel in series {}".format(snap_name, series) ) packages = [{"name": snap_name, "series": series}] channels = ["edge"] _acquire_and_encrypt_credentials(packages, channels) logger.info( "Done. Please commit the changes to `{}` file.".format( ENCRYPTED_CONFIG_FILENAME ) )
def make_snapcraft_project(self, parts, snap_type=""): yaml = textwrap.dedent( """\ name: test version: 0 summary: test description: test confinement: strict grade: stable {type} {parts} """ ) self.snapcraft_yaml_file_path = self.make_snapcraft_yaml( yaml.format(parts=parts, type=snap_type) ) project = snapcraft.project.Project( snapcraft_yaml_file_path=self.snapcraft_yaml_file_path ) return project_loader.load_config(project)