def test_one_repo_save_and_load(self): """ Tests the normal flow of saving and loading, using only one repo to minimize complications. """ # Setup add_me = Repo('test-repo-1') add_me['baseurl'] = 'http://localhost/repo' add_me['enabled'] = 1 add_me['gpgkey'] = '/tmp/key' add_me['sslverify'] = 0 add_me['gpgcheck'] = 0 add_me['sslcacert'] = '/tmp/sslcacert' add_me['sslclientcert'] = '/tmp/clientcert' repo_file = RepoFile(TEST_REPO_FILENAME) # Test Save repo_file.add_repo(add_me) repo_file.save() # Verify Save self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) # Test Load loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() # Verify Load self.assertEqual(1, len(loaded.all_repos())) found_repo = loaded.get_repo('test-repo-1') self.assertTrue(found_repo is not None) self.assertTrue(_repo_eq(add_me, found_repo))
def test_multiple_repos(self): """ Tests saving and loading multiple repos. """ # Setup repo1 = Repo('test-repo-1') repo1['baseurl'] = 'http://localhost/repo1' repo2 = Repo('test-repo-2') repo2['baseurl'] = 'http://localhost/repo2' repo_file = RepoFile(TEST_REPO_FILENAME) # Test repo_file.add_repo(repo1) repo_file.add_repo(repo2) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() self.assertEqual(2, len(loaded.all_repos())) found_repo1 = loaded.get_repo('test-repo-1') self.assertTrue(found_repo1 is not None) self.assertTrue(_repo_eq(repo1, found_repo1)) found_repo2 = loaded.get_repo('test-repo-2') self.assertTrue(found_repo2 is not None) self.assertTrue(_repo_eq(repo2, found_repo2))
def test_bind_update_keys(self): """ Tests changing the GPG keys on a previously bound repo. """ # Setup keys = {'key1' : 'KEY1', 'key2' : 'KEY2'} repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], keys, None, None, ENABLED, LOCK) # Test new_keys = {'key1' : 'KEYX'} repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, None, None, new_keys, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '1') self.assertEqual(1, len(loaded['gpgkey'].split('\n'))) self.assertEqual(1, len(os.listdir(os.path.join(TEST_KEYS_DIR, REPO_ID)))) key_file = open(loaded['gpgkey'].split('\n')[0][5:], 'r') contents = key_file.read() key_file.close() self.assertEqual(contents, 'KEYX')
def test_bind_multiple_url(self): """ Tests that binding with a list of URLs will produce a mirror list and the correct mirrorlist entry in the repo entry. """ # Test url_list = ['http://pulpserver', 'http://otherserver'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, None, ENABLED, LOCK) # Verify self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) self.assertTrue(os.path.exists(TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertTrue('baseurl' not in loaded) self.assertEqual(loaded['mirrorlist'], 'file:' + TEST_MIRROR_LIST_FILENAME) mirror_list_file = MirrorListFile(TEST_MIRROR_LIST_FILENAME) mirror_list_file.load() self.assertEqual(mirror_list_file.entries[0], 'http://pulpserver') self.assertEqual(mirror_list_file.entries[1], 'http://otherserver')
def test_delete_repo(self): """ Tests removing an existing repo is correctly saved and loaded """ # Setup repo1 = Repo('test-repo-1') repo2 = Repo('test-repo-2') repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo1) repo_file.add_repo(repo2) repo_file.save() # Test repo_file.remove_repo_by_name('test-repo-1') repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() self.assertEqual(1, len(loaded.all_repos())) self.assertTrue(loaded.get_repo('test-repo-1') is None) self.assertTrue(loaded.get_repo('test-repo-2') is not None)
def test_broken_load_allow_missing(self): """ Tests that an exception is raised when the file cannot be loaded because it is not found. """ # Test repo_file = RepoFile('/a/b/c/d') repo_file.load(allow_missing=True)
def test_no_repos_save_load(self): """ Tests that saving and loading a file with no repos is successful. """ # Test repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() # Verify self.assertEqual(0, len(loaded.all_repos()))
def test_update_clientcert(self): # setup NEWCLIENTCRT = 'THE-NEW-CLIENT-CERT' repolib.bind( TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CACERT, CLIENTCERT, ENABLED, LOCK) repolib.bind( TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], [], CACERT, NEWCLIENTCRT, ENABLED, LOCK) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) # verify certdir = os.path.join(TEST_CERT_DIR, REPO_ID) self.assertTrue(len(os.listdir(certdir)), 2) path = loaded['sslcacert'] f = open(path) content = f.read() f.close() self.assertEqual(CACERT, content) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(NEWCLIENTCRT, content) self.assertTrue(loaded['sslverify'], '1')
def test_bind_host_urls_many_to_one(self): """ Tests that changing from multiple URLs (mirrorlist usage) to a single URL properly sets the repo metadata. """ # Setup url_list = ['http://pulp1', 'http://pulp2'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, None, None, None, ENABLED, LOCK) # Test repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulpx'], None, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertTrue('baseurl' in loaded) self.assertTrue('mirrorlist' not in loaded)
def test_bind_multiple_keys(self): """ Tests that binding with multiple key URLs correctly stores the repo entry. """ # Test url_list = ['http://pulpserver'] keys = {'key1' : 'KEY1', 'key2' : 'KEY2'} repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, keys, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '1') self.assertEqual(2, len(loaded['gpgkey'].split('\n'))) self.assertEqual(2, len(os.listdir(os.path.join(TEST_KEYS_DIR, REPO_ID))))
def test_bind_single_url(self): """ Tests that binding with a single URL will produce a baseurl in the repo. """ # Test url_list = ['http://pulpserver'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, None, ENABLED, LOCK) # Verify self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded)
def test_bind_host_urls_one_to_many(self): """ Tests that changing from a single URL to many properly updates the baseurl and mirrorlist entries of the repo. """ # Setup repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['https://pulpx'], None, None, None, ENABLED, LOCK) # Test url_list = ['http://pulp1', 'http://pulp2'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, None, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertTrue('baseurl' not in loaded) self.assertTrue('mirrorlist' in loaded)
def test_unbind_repo_with_mirrorlist(self): """ Tests that unbinding a repo that had a mirror list deletes the mirror list file. """ # Setup url_list = ['http://pulp1', 'http://pulp2', 'http://pulp3'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, None, ENABLED, LOCK) self.assertTrue(os.path.exists(TEST_MIRROR_LIST_FILENAME)) # Test repolib.unbind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() self.assertEqual(0, len(repo_file.all_repos())) self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME))
def test_bind_update_remove_keys(self): """ Tests that updating a previously bound repo by removing its keys correctly configures the repo and deletes the key files. """ # Setup keys = {'key1' : 'KEY1', 'key2' : 'KEY2'} repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, ['http://pulp'], keys, None, None, ENABLED, LOCK) # Test repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, None, None, {}, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertTrue(not os.path.exists(os.path.join(TEST_KEYS_DIR, REPO_ID)))
def test_mirrorlist_not_baseurl(self): """ Tests that if a mirrorlist is specified, a baseurl entry isn't written to the saved repo file. """ # Setup repo = Repo('test-repo-1') repo['mirrorlist'] = 'file://etc/pulp/mirrorlist' repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo) repo_file.save() # Test loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() loaded_repo = loaded.get_repo('test-repo-1') self.assertEqual(loaded_repo['mirrorlist'], 'file://etc/pulp/mirrorlist') self.assertTrue('baseurl' not in loaded_repo)
def test_bind_update_repo(self): """ Tests calling bind on an existing repo with new repo data. The host URL and key data remain unchanged. """ # Setup url_list = ['http://pulp1', 'http://pulp2'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, None, None, None, ENABLED, LOCK) # Test updated_name = 'Updated' repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, updated_name, None, None, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['name'], updated_name)
def test_bind_existing_file(self): """ Tests binding a new repo when the underlying file exists and has repos in it (the existing repo shouldn't be deleted). """ # Setup repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(Repo('existing-repo-1')) repo_file.save() # Test url_list = ['http://pulpserver'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, None, None, ENABLED, LOCK) # Verify self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() self.assertEqual(2, len(repo_file.all_repos()))
def test_bind_new_file(self): """ Tests binding a repo when the underlying .repo file does not exist. """ # Test url_list = ['http://pulpserver'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, {}, CACERT, CLIENTCERT, ENABLED, LOCK) # Verify self.assertTrue(os.path.exists(TEST_REPO_FILENAME)) self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME)) repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() self.assertEqual(1, len(repo_file.all_repos())) loaded = repo_file.get_repo(REPO_ID) self.assertTrue(loaded is not None) self.assertEqual(loaded['name'], REPO_NAME) self.assertTrue(loaded['enabled']) self.assertEqual(loaded['gpgcheck'], '0') self.assertEqual(loaded['gpgkey'], None) self.assertEqual(loaded['baseurl'], url_list[0]) self.assertTrue('mirrorlist' not in loaded) path = loaded['sslcacert'] f = open(path) content = f.read() f.close() self.assertEqual(CACERT, content) path = loaded['sslclientcert'] f = open(path) content = f.read() f.close() self.assertEqual(CLIENTCERT, content) self.assertTrue(loaded['sslverify'], '1')
def test_unbind_repo_exists(self): """ Tests the normal case of unbinding a repo that exists in the repo file. """ # Setup repoid = 'test-unbind-repo' repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(Repo(repoid)) repo_file.save() # Test repolib.unbind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, 'test-unbind-repo', LOCK) # verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load(allow_missing=False) # the file should still be there, so error if it doesn't self.assertEqual(0, len(repo_file.all_repos())) certdir = os.path.join(TEST_CERT_DIR, repoid) self.assertFalse(os.path.exists(certdir))
def test_bind_update_host_urls(self): """ Tests calling bind on an existing repo with new repo data. This test will test the more complex case where a mirror list existed in the original repo but is not necessary in the updated repo. """ # Setup url_list = ['http://pulp1', 'http://pulp2'] repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, REPO_NAME, url_list, None, None, None, ENABLED, LOCK) self.assertTrue(os.path.exists(TEST_MIRROR_LIST_FILENAME)) # Test repolib.bind(TEST_REPO_FILENAME, TEST_MIRROR_LIST_FILENAME, TEST_KEYS_DIR, TEST_CERT_DIR, REPO_ID, None, ['http://pulpx'], None, None, None, ENABLED, LOCK) # Verify repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.load() loaded = repo_file.get_repo(REPO_ID) self.assertEqual(loaded['baseurl'], 'http://pulpx') self.assertTrue(not os.path.exists(TEST_MIRROR_LIST_FILENAME))
def test_update_repo(self): """ Tests that updating an existing repo is correctly saved. """ # Setup repo1 = Repo('test-repo-1') repo1['baseurl'] = 'http://localhost/repo1' repo_file = RepoFile(TEST_REPO_FILENAME) repo_file.add_repo(repo1) repo_file.save() # Test repo1['baseurl'] = 'http://localhost/repo-updated' repo_file.update_repo(repo1) repo_file.save() # Verify loaded = RepoFile(TEST_REPO_FILENAME) loaded.load() found_repo = loaded.get_repo('test-repo-1') self.assertEqual(found_repo['baseurl'], 'http://localhost/repo-updated')
def unbind(repo_filename, mirror_list_filename, keys_root_dir, cert_root_dir, repo_id, lock=None): """ Removes the repo identified by repo_id from the given repo file. If the repo is not bound, this call has no effect. If the mirror list file exists, it will be deleted. The default lock is defined at the module level and is used to ensure that concurrent access to the give files is prevented. Specific locks can be passed in for testing purposes to circumvent the default location of the lock which requires root access. @param repo_filename: full path to the location of the repo file in which the repo will be removed; if this file does not exist this call has no effect @type repo_filename: string @param mirror_list_filename: full path to the location of the mirror list file that may exist for the given repo; if the file does not exist this field will be ignored @type mirror_list_filename: string @param keys_root_dir: absolute path to the root directory in which the keys for all repos will be stored @type keys_root_dir: string @param cert_root_dir: absolute path to the root directory in which the certs for all repos will be stored @type cert_root_dir: string @param repo_id: identifies the repo in the repo file to delete @type repo_id: string @param lock: if the default lock is unacceptble, it may be overridden in this variable @type lock: L{Lock} """ if not lock: lock = Lock('/var/run/subsys/pulp/repolib.pid') lock.acquire() try: log.info('Unbinding repo [%s]' % repo_id) if not os.path.exists(repo_filename): return # Repo file changes repo_file = RepoFile(repo_filename) repo_file.load() repo_file.remove_repo_by_name(repo_id) # will not throw an error if repo doesn't exist repo_file.save() # Mirror list removal if os.path.exists(mirror_list_filename): os.remove(mirror_list_filename) # Keys removal repo_keys = RepoKeyFiles(keys_root_dir, repo_id) repo_keys.update_filesystem() # cert removal certificates = CertFiles(cert_root_dir, repo_id) certificates.apply() finally: lock.release()
def bind(repo_filename, mirror_list_filename, keys_root_dir, cert_root_dir, repo_id, repo_name, url_list, gpg_keys, cacert, clientcert, enabled, lock=None): """ Uses the given data to safely bind a repo to a repo file. This call will determine the best method for representing the repo given the data in the repo object as well as the list of URLs where the repo can be found. The default lock is defined at the module level and is used to ensure that concurrent access to the give files is prevented. Specific locks can be passed in for testing purposes to circumvent the default location of the lock which requires root access. @param repo_filename: full path to the location of the repo file in which the repo will be bound; this file does not need to exist prior to this call @type repo_filename: string @param mirror_list_filename: full path to the location of the mirror list file that should be written for the given repo if necessary; this should be unique for the given repo @type mirror_list_filename: string @param keys_root_dir: absolute path to the root directory in which the keys for all repos will be stored @type keys_root_dir: string @param cert_root_dir: absolute path to the root directory in which the certs for all repos will be stored @type cert_root_dir: string @param repo_id: uniquely identifies the repo being updated @type repo_id: string @param repo_name: the repo name @type repo_name: str @param url_list: list of URLs that will be used to access the repo; this call will determine the best way to represent the URL list in the repo definition @type url_list: list of strings @param gpg_keys: mapping of key name to contents for GPG keys to be used when verifying packages from this repo @type gpg_keys: dict {string: string} @param cacert: The CA certificate (PEM). @type cacert: str @param clientcert: The client certificate (PEM). @type clientcert: str @param lock: if the default lock is unacceptble, it may be overridden in this variable @type lock: L{Lock} """ if not lock: lock = Lock('/var/run/subsys/pulp/repolib.pid') lock.acquire() try: log.info('Binding repo [%s]' % repo_id) repo_file = RepoFile(repo_filename) repo_file.load() # In the case of an update, only the changed values will have been sent. # Therefore, any of the major data components (repo data, url list, keys) # may be None. if repo_name is not None: repo = _convert_repo(repo_id, enabled, repo_name) else: repo = repo_file.get_repo(repo_id) if gpg_keys is not None: _handle_gpg_keys(repo, gpg_keys, keys_root_dir) _handle_certs(repo, cert_root_dir, cacert, clientcert) if url_list is not None: _handle_host_urls(repo, url_list, mirror_list_filename) if repo_file.get_repo(repo.id): log.info('Updating existing repo [%s]' % repo.id) repo_file.update_repo(repo) else: log.info('Adding new repo [%s]' % repo.id) repo_file.add_repo(repo) repo_file.save() finally: lock.release()