def do_publish(self, download_policy): """Publish repository synced with lazy download policy.""" repo_api = RepositoriesFileApi(self.client) remote_api = RemotesFileApi(self.client) publications = PublicationsFileApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_file_remote(policy=download_policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) publish_data = FileFilePublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) publication = publications.read(publication_href) self.assertIsNotNone(publication.repository_version, publication)
def setUpClass(cls): """ Initialize Pulp to make authorization assertions using client certificates. 0. Create a FileRepository 1. Create a FileRemote 2. Sync in a few units we can use to fetch with 3. Create a Publication 4. Create a CertGuard with the CA cert used to sign all client certificates 5. Create a Distribution for the publication that is protected by the CertGuard """ cls.teardown_cleanups = [] cls.cfg = config.get_config() file_client = gen_file_client() repo_api = RepositoriesFileApi(file_client) remote_api = RemotesFileApi(file_client) publications = PublicationsFileApi(file_client) cls.distributions_api = DistributionsFileApi(file_client) cls.repo = repo_api.create(gen_repo()) cls.teardown_cleanups.append((repo_api.delete, cls.repo.pulp_href)) body = gen_file_remote(policy="immediate") remote = remote_api.create(body) cls.teardown_cleanups.append((remote_api.delete, remote.pulp_href)) # Sync a Repository repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(cls.repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) cls.repo = repo_api.read(cls.repo.pulp_href) # Create a publication. publish_data = FileFilePublication(repository=cls.repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] cls.teardown_cleanups.append((publications.delete, publication_href)) content_guard_href = cls._setup_content_guard() # Create a distribution. body = gen_distribution() body["publication"] = publication_href body["content_guard"] = content_guard_href distribution_response = cls.distributions_api.create(body) created_resources = monitor_task(distribution_response.task) cls.distribution = cls.distributions_api.read(created_resources[0]) cls.teardown_cleanups.append((cls.distributions_api.delete, cls.distribution.pulp_href))
def setUpClass(cls): """Sets up class""" client = gen_file_client() cls.cont_api = ContentFilesApi(client) cls.repo_api = RepositoriesFileApi(client) cls.remote_api = RemotesFileApi(client) cls.pub_api = PublicationsFileApi(client) cls.dis_api = DistributionsFileApi(client) cls.repo = cls.repo_api.create(gen_repo(autopublish=True)) cls.remote = cls.remote_api.create(gen_file_remote()) body = RepositorySyncURL(remote=cls.remote.pulp_href) created = monitor_task( cls.repo_api.sync(cls.repo.pulp_href, body).task).created_resources cls.repo = cls.repo_api.read(cls.repo.pulp_href) cls.pub1 = cls.pub_api.read(created[1]) body = FileFilePublication(repository=cls.repo.pulp_href) cls.pub2 = cls.pub_api.read( monitor_task(cls.pub_api.create(body).task).created_resources[0]) cls.pub3 = [] response = cls.dis_api.create( gen_distribution(repository=cls.repo.pulp_href)) cls.distro = cls.dis_api.read( monitor_task(response.task).created_resources[0]) cls.distro2 = [] cls.url = urljoin(PULP_CONTENT_BASE_URL, f"{cls.distro.base_path}/")
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.file_client = gen_file_client() cls.repo_api = RepositoriesFileApi(cls.file_client) cls.publication_api = PublicationsFileApi(cls.file_client) cls.remote_api = RemotesFileApi(cls.file_client)
def setUp(self): """Add content to Pulp.""" self.cfg = config.get_config() self.client = api.Client(self.cfg, api.json_handler) self.core_client = CoreApiClient(configuration=self.cfg.get_bindings_config()) self.file_client = gen_file_client() self.content_api = ContentFilesApi(self.file_client) self.repo_api = RepositoriesFileApi(self.file_client) self.version_api = RepositoriesFileVersionsApi(self.file_client) self.distro_api = DistributionsFileApi(self.file_client) self.publication_api = PublicationsFileApi(self.file_client) delete_orphans() populate_pulp(self.cfg, url=FILE_LARGE_FIXTURE_MANIFEST_URL) self.content = sample(self.content_api.list().results, 3) self.publications = []
def setUpClass(cls): """Clean out Pulp before testing.""" delete_orphans() client = gen_file_client() cls.repo_api = RepositoriesFileApi(client) cls.remote_api = RemotesFileApi(client) cls.publication_api = PublicationsFileApi(client) cls.distributions_api = DistributionsFileApi(client) cls.cfg = config.get_config()
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_file_client() cls.content_api = ContentFilesApi(cls.client) cls.repo_api = RepositoriesFileApi(cls.client) cls.remote_api = RemotesFileApi(cls.client) cls.publications_api = PublicationsFileApi(cls.client) cls.distributions_api = DistributionsFileApi(cls.client) cls.CUSTOM_MANIFEST = "TEST_MANIFEST"
def test_access_error(self): """HTTP error is not raised when accessing published data.""" repo_api = RepositoriesFileApi(self.client) remote_api = RemotesFileApi(self.client) publications = PublicationsFileApi(self.client) distributions = DistributionsFileApi(self.client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) remote = remote_api.create(gen_file_remote()) self.addCleanup(remote_api.delete, remote.pulp_href) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) publish_data = FileFilePublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task( publish_response.task).created_resources publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) body = gen_distribution() body["publication"] = publication_href distribution_response = distributions.create(body) created_resources = monitor_task( distribution_response.task).created_resources distribution = distributions.read(created_resources[0]) self.addCleanup(distributions.delete, distribution.pulp_href) pulp_manifest = parse_pulp_manifest( self.download_pulp_manifest(distribution.to_dict(), "PULP_MANIFEST")) self.assertEqual(len(pulp_manifest), FILE_FIXTURE_COUNT, pulp_manifest)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = gen_file_client() cls.orphans_api = OrphansCleanupApi(core_client) cls.reclaim_api = RepositoriesReclaimSpaceApi(core_client) cls.artifacts_api = ArtifactsApi(core_client) cls.publication_api = PublicationsFileApi(cls.client) cls.distributions_api = DistributionsFileApi(cls.client) cls.repo_api = RepositoriesFileApi(cls.client) cls.remote_api = RemotesFileApi(cls.client) orphans_response = cls.orphans_api.cleanup( {"orphan_protection_time": 0}) monitor_task(orphans_response.task)
def setUpClass(cls): """Create class-wide variables.""" cls.cfg = config.get_config() cls.client = api.Client(cls.cfg, api.json_handler) cls.file_client = gen_file_client() cls.content_api = ContentFilesApi(cls.file_client) cls.repo_api = RepositoriesFileApi(cls.file_client) cls.versions_api = RepositoriesFileVersionsApi(cls.file_client) cls.remote_api = RemotesFileApi(cls.file_client) cls.publication_api = PublicationsFileApi(cls.file_client) cls.exporter_api = ExportersFilesystemApi(cls.file_client) cls.exports_api = ExportersFileExportsApi(cls.file_client) cls.repos, cls.remotes, cls.publications = cls._setup_repositories()
def setUpClass(cls): """ Create class-wide variables. Variables 'paths' and 'paths_updated' are defined as strings. In same way data are send from user. """ cls.cfg = config.get_config() cls.file_client = gen_file_client() cls.repo_api = RepositoriesFileApi(cls.file_client) cls.file_remote_api = RemotesFileApi(cls.file_client) cls.file_acs_api = AcsFileApi(cls.file_client) cls.publication_api = PublicationsFileApi(cls.file_client) cls.distribution_api = DistributionsFileApi(cls.file_client) cls.paths = ["goodpath/PULP_MANIFEST", "test", "whatever/test"]
def setUpClass(cls): """ Create all the client instances needed to communicate with Pulp. """ configuration = Configuration(**BINDINGS_CONFIGURATION) file_client = FileApiClient(configuration) migration_client = MigrationApiClient(configuration) # Create api clients for all resource types cls.file_repo_api = RepositoriesFileApi(file_client) cls.file_repo_versions_api = RepositoriesFileVersionsApi(file_client) cls.file_remote_api = RemotesFileApi(file_client) cls.file_distribution_api = DistributionsFileApi(file_client) cls.file_publication_api = PublicationsFileApi(file_client) cls.file_content_api = ContentFilesApi(file_client) cls.migration_plans_api = MigrationPlansApi(migration_client) cls.pulp2content_api = Pulp2ContentApi(migration_client) cls.pulp2repositories_api = Pulp2RepositoriesApi(migration_client)
def setUpClass(cls): """ Create all the client instances needed to communicate with Pulp. """ configuration = Configuration(**BINDINGS_CONFIGURATION) file_client = FileApiClient(configuration) rpm_client = RpmApiClient(configuration) migration_client = MigrationApiClient(configuration) # Create api clients for File cls.file_repo_api = RepositoriesFileApi(file_client) cls.file_repo_versions_api = RepositoriesFileVersionsApi(file_client) cls.file_remote_api = RemotesFileApi(file_client) cls.file_distribution_api = DistributionsFileApi(file_client) cls.file_publication_api = PublicationsFileApi(file_client) cls.file_content_api = ContentFilesApi(file_client) # Create api clients for RPM cls.rpm_repo_api = RepositoriesRpmApi(rpm_client) cls.rpm_repo_versions_api = RepositoriesRpmVersionsApi(rpm_client) cls.rpm_remote_api = RemotesRpmApi(rpm_client) cls.rpm_distribution_api = DistributionsRpmApi(rpm_client) cls.rpm_publication_api = PublicationsRpmApi(rpm_client) cls.rpm_content_apis = { 'advisory': ContentAdvisoriesApi(rpm_client), 'disttree': ContentDistributionTreesApi(rpm_client), 'modulemd': ContentModulemdsApi(rpm_client), 'modulemd-defaults': ContentModulemdDefaultsApi(rpm_client), 'category': ContentPackagecategoriesApi(rpm_client), 'environment': ContentPackageenvironmentsApi(rpm_client), 'group': ContentPackagegroupsApi(rpm_client), 'langpack': ContentPackagelangpacksApi(rpm_client), 'package': ContentPackagesApi(rpm_client), } # Create api clients for Migration cls.migration_plans_api = MigrationPlansApi(migration_client) cls.pulp2content_api = Pulp2ContentApi(migration_client) cls.pulp2repositories_api = Pulp2RepositoriesApi(migration_client)
# Configure HTTP basic authorization: basic configuration = Configuration() configuration.username = '******' configuration.password = '******' configuration.safe_chars_for_path_param = '/' core_client = CoreApiClient(configuration) file_client = FileApiClient(configuration) # Create api clients for all resource types artifacts = ArtifactsApi(core_client) repositories = RepositoriesApi(core_client) repoversions = RepositoriesVersionsApi(core_client) filecontent = ContentFilesApi(file_client) filedistributions = DistributionsFileApi(core_client) filepublications = PublicationsFileApi(file_client) fileremotes = RemotesFileApi(file_client) tasks = TasksApi(core_client) uploads = UploadsApi(core_client) # Test creating an Artifact from a 1mb file uploaded in 200kb chunks with NamedTemporaryFile() as downloaded_file: response = requests.get( 'https://repos.fedorapeople.org/repos/pulp/pulp/demo_repos/test_bandwidth_repo/' 'pulp-large_1mb_test-packageA-0.1.1-1.fc14.noarch.rpm') response.raise_for_status() downloaded_file.write(response.content) artifact = upload_file_in_chunks(downloaded_file.name) pprint(artifact)
def test_all(self): """Test whether a particular repository version can be published. 1. Create a repository with at least 2 repository versions. 2. Create a publication by supplying the latest ``repository_version``. 3. Assert that the publication ``repository_version`` attribute points to the latest repository version. 4. Create a publication by supplying the non-latest ``repository_version``. 5. Assert that the publication ``repository_version`` attribute points to the supplied repository version. 6. Assert that an exception is raised when providing two different repository versions to be published at same time. """ cfg = config.get_config() client = gen_file_client() repo_api = RepositoriesFileApi(client) remote_api = RemotesFileApi(client) publications = PublicationsFileApi(client) body = gen_file_remote() remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) # Step 1 repo = repo_api.read(repo.pulp_href) for file_content in get_content(repo.to_dict())[FILE_CONTENT_NAME]: modify_repo(cfg, repo.to_dict(), remove_units=[file_content]) version_hrefs = tuple(ver["pulp_href"] for ver in get_versions(repo.to_dict())) non_latest = choice(version_hrefs[:-1]) # Step 2 publish_data = FileFilePublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) publication = publications.read(publication_href) # Step 3 self.assertEqual(publication.repository_version, version_hrefs[-1]) # Step 4 publish_data = FileFilePublication(repository_version=non_latest) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] publication = publications.read(publication_href) # Step 5 self.assertEqual(publication.repository_version, non_latest) # Step 6 with self.assertRaises(ApiException): body = { "repository": repo.pulp_href, "repository_version": non_latest } publications.create(body)
def do_test(self, policy): """Verify whether content served by pulp can be downloaded. The process of publishing content is more involved in Pulp 3 than it was under Pulp 2. Given a repository, the process is as follows: 1. Create a publication from the repository. (The latest repository version is selected if no version is specified.) A publication is a repository version plus metadata. 2. Create a distribution from the publication. The distribution defines at which URLs a publication is available, e.g. ``http://example.com/content/foo/`` and ``http://example.com/content/bar/``. Do the following: 1. Create, populate, publish, and distribute a repository. 2. Select a random content unit in the distribution. Download that content unit from Pulp, and verify that the content unit has the same checksum when fetched directly from Pulp-Fixtures. This test targets the following issues: * `Pulp #2895 <https://pulp.plan.io/issues/2895>`_ * `Pulp Smash #872 <https://github.com/pulp/pulp-smash/issues/872>`_ """ cfg = config.get_config() client = gen_file_client() repo_api = RepositoriesFileApi(client) remote_api = RemotesFileApi(client) publications = PublicationsFileApi(client) distributions = DistributionsFileApi(client) repo = repo_api.create(gen_repo()) self.addCleanup(repo_api.delete, repo.pulp_href) body = gen_file_remote(policy=policy) remote = remote_api.create(body) self.addCleanup(remote_api.delete, remote.pulp_href) # Sync a Repository repository_sync_data = RepositorySyncURL(remote=remote.pulp_href) sync_response = repo_api.sync(repo.pulp_href, repository_sync_data) monitor_task(sync_response.task) repo = repo_api.read(repo.pulp_href) # Create a publication. publish_data = FileFilePublication(repository=repo.pulp_href) publish_response = publications.create(publish_data) created_resources = monitor_task(publish_response.task) publication_href = created_resources[0] self.addCleanup(publications.delete, publication_href) # Create a distribution. body = gen_distribution() body["publication"] = publication_href distribution_response = distributions.create(body) created_resources = monitor_task(distribution_response.task) distribution = distributions.read(created_resources[0]) self.addCleanup(distributions.delete, distribution.pulp_href) # Pick a file, and download it from both Pulp Fixtures… unit_path = choice(get_file_content_paths(repo.to_dict())) fixtures_hash = hashlib.sha256( utils.http_get(urljoin(FILE_FIXTURE_URL, unit_path))).hexdigest() # …and Pulp. content = download_content_unit(cfg, distribution.to_dict(), unit_path) pulp_hash = hashlib.sha256(content).hexdigest() self.assertEqual(fixtures_hash, pulp_hash)
class RepoVersionRetentionTestCase(unittest.TestCase): """Test retain_repo_versions for repositories This test targets the following issues: * `Pulp #8368 <https:://pulp.plan.io/issues/8368>`_ """ @classmethod def setUp(self): """Add content to Pulp.""" self.cfg = config.get_config() self.client = api.Client(self.cfg, api.json_handler) self.core_client = CoreApiClient(configuration=self.cfg.get_bindings_config()) self.file_client = gen_file_client() self.content_api = ContentFilesApi(self.file_client) self.repo_api = RepositoriesFileApi(self.file_client) self.version_api = RepositoriesFileVersionsApi(self.file_client) self.distro_api = DistributionsFileApi(self.file_client) self.publication_api = PublicationsFileApi(self.file_client) delete_orphans() populate_pulp(self.cfg, url=FILE_LARGE_FIXTURE_MANIFEST_URL) self.content = sample(self.content_api.list().results, 3) self.publications = [] def _create_repo_versions(self, repo_attributes={}): self.repo = self.repo_api.create(gen_repo(**repo_attributes)) self.addCleanup(self.repo_api.delete, self.repo.pulp_href) if "autopublish" in repo_attributes and repo_attributes["autopublish"]: self.distro = create_distribution(repository_href=self.repo.pulp_href) self.addCleanup(self.distro_api.delete, self.distro.pulp_href) for content in self.content: result = self.repo_api.modify( self.repo.pulp_href, {"add_content_units": [content.pulp_href]} ) monitor_task(result.task) self.repo = self.repo_api.read(self.repo.pulp_href) self.publications += self.publication_api.list( repository_version=self.repo.latest_version_href ).results def test_retain_repo_versions(self): """Test repo version retention.""" self._create_repo_versions({"retain_repo_versions": 1}) versions = self.version_api.list(file_file_repository_href=self.repo.pulp_href).results self.assertEqual(len(versions), 1) latest_version = self.version_api.read( file_file_repository_version_href=self.repo.latest_version_href ) self.assertEqual(latest_version.number, 3) self.assertEqual(latest_version.content_summary.present["file.file"]["count"], 3) self.assertEqual(latest_version.content_summary.added["file.file"]["count"], 3) def test_retain_repo_versions_on_update(self): """Test repo version retention when retain_repo_versions is set.""" self._create_repo_versions() versions = self.version_api.list(file_file_repository_href=self.repo.pulp_href).results self.assertEqual(len(versions), 4) # update retain_repo_versions to 2 result = self.repo_api.partial_update(self.repo.pulp_href, {"retain_repo_versions": 2}) monitor_task(result.task) versions = self.version_api.list(file_file_repository_href=self.repo.pulp_href).results self.assertEqual(len(versions), 2) latest_version = self.version_api.read( file_file_repository_version_href=self.repo.latest_version_href ) self.assertEqual(latest_version.number, 3) self.assertEqual(latest_version.content_summary.present["file.file"]["count"], 3) self.assertEqual(latest_version.content_summary.added["file.file"]["count"], 1) def test_autodistribute(self): """Test repo version retention with autopublish/autodistribute.""" self._create_repo_versions({"retain_repo_versions": 1, "autopublish": True}) # all but the last publication should be gone for publication in self.publications[:-1]: with self.assertRaises(ApiException) as ae: self.publication_api.read(publication.pulp_href) self.assertEqual(404, ae.exception.status) # check that the last publication is distributed manifest = download_content_unit(self.cfg, self.distro.to_dict(), "PULP_MANIFEST") self.assertEqual(manifest.decode("utf-8").count("\n"), len(self.content))