def test_create_missing_repo(self):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry)
        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid],
            fields=['id']).and_return([]).once().ordered())
        (flexmock(mockpulp).should_receive('createRepo').with_args(
            prefixed_pulp_repoid,
            None,
            registry_id=docker_repository,
            prefix_with='redhat-').once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
    def test_pulp_repo_prefix(self,
                              get_prefix,
                              pulp_repo_prefix,
                              expected_prefix, reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
        env = 'pulp'
        kwargs = {}
        if pulp_repo_prefix:
            kwargs['pulp_repo_prefix'] = pulp_repo_prefix

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                **kwargs)

        mockpulp = MockPulp()
        if get_prefix:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_return(expected_prefix))
        else:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_raise(AttributeError))

        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_delete_not_implemented(self, caplog, reactor_config_map):  # noqa
        """
        Should log an error (but not raise an exception) when
        delete_from_registry is True.
        """
        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            ['redhat-prod-myrepository'], fields=['id']).and_return([{
                'id':
                'redhat-prod-myrepository'
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                delete_from_registry=True)
        plugin.run()

        errors = [
            record.getMessage() for record in caplog.records()
            if record.levelname == 'ERROR'
        ]

        assert [message for message in errors if 'not implemented' in message]
    def test_create_missing_repo(self, reactor_config_map):  # noqa
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid],
            fields=['id']).and_return([]).once().ordered())
        (flexmock(mockpulp).should_receive('createRepo').with_args(
            prefixed_pulp_repoid,
            None,
            registry_id=docker_repository,
            prefix_with='redhat-').once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
    def test_insecure_registry(self, insecure_registry, ssl_validation):
        docker_registry = "http://registry.example.com"
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "redhat-prod-myrepository"
        env = "pulp"
        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow([docker_repository]),
            pulp_registry_name=env,
            docker_registry=docker_registry,
            insecure_registry=insecure_registry,
        )

        mockpulp = MockPulp()
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args([prefixed_pulp_repoid], fields=["id"])
            .and_return([{"id": prefixed_pulp_repoid}])
            .once()
            .ordered()
        )
        sync_exp = flexmock(mockpulp).should_receive("syncRepo")
        if ssl_validation is None:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
        else:
            sync_exp = sync_exp.with_args(
                repo=prefixed_pulp_repoid, feed=docker_registry, ssl_validation=ssl_validation
            )

        (sync_exp.and_return(([], [])).once().ordered())
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        plugin.run()
    def test_dockercfg_missing_or_invalid(self, tmpdir, content, reactor_config_map):
        env = 'pulp'

        if content is not None:
            registry_secret = os.path.join(str(tmpdir), '.dockercfg')
            with open(registry_secret, 'w') as fp:
                fp.write(content)

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['repo']),
                                pulp_registry_name=env,
                                docker_registry='http://registry.example.com',
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        with pytest.raises(RuntimeError):
            plugin.run()
    def test_store_registry(self, already_exists):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            object,
            'prod-myrepository',  # pulp repository name
            config_file=object).and_return([{
                'id': 'prefix-prod-myrepository'
            }])  # repo id
         .once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            ['prefix-prod-myrepository'],  # repo id
            wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_delete_not_implemented(self, caplog):
        """
        Should log an error (but not raise an exception) when
        delete_from_registry is True.
        """
        mockpulp = MockPulp()
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args(["redhat-prod-myrepository"], fields=["id"])
            .and_return([{"id": "redhat-prod-myrepository"}])
            .once()
            .ordered()
        )
        (flexmock(mockpulp).should_receive("syncRepo").and_return(([], [])))
        flexmock(dockpulp).should_receive("Pulp").and_return(mockpulp)
        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow(["prod/myrepository"]),
            pulp_registry_name="pulp",
            docker_registry="http://registry.example.com",
            delete_from_registry=True,
        )

        plugin.run()

        errors = [record.getMessage() for record in caplog.records() if record.levelname == "ERROR"]

        assert [message for message in errors if "not implemented" in message]
    def test_store_registry(self, already_exists):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_dockercfg_missing_or_invalid(self, tmpdir, content,
                                          reactor_config_map):
        env = 'pulp'

        if content is not None:
            registry_secret = os.path.join(str(tmpdir), '.dockercfg')
            with open(registry_secret, 'w') as fp:
                fp.write(content)

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['repo']),
                                pulp_registry_name=env,
                                docker_registry='http://registry.example.com',
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        with pytest.raises(RuntimeError):
            plugin.run()
    def test_insecure_registry(self, insecure_registry, ssl_validation):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                insecure_registry=insecure_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        sync_exp = flexmock(mockpulp).should_receive('syncRepo')
        if ssl_validation is None:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry)
        else:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry,
                                          ssl_validation=ssl_validation)

        (sync_exp.and_return(([], [])).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
    def test_delete_not_implemented(self, caplog):
        """
        Should log an error (but not raise an exception) when
        delete_from_registry is True.
        """
        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            ['redhat-prod-myrepository'], fields=['id']).and_return([{
                'id':
                'redhat-prod-myrepository'
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                delete_from_registry=True)

        plugin.run()

        errors = [
            record.getMessage() for record in caplog.records()
            if record.levelname == 'ERROR'
        ]

        assert [message for message in errors if 'not implemented' in message]
    def test_auth_none(self):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            object,
            'prod-myrepository',  # pulp repository name
            config_file=object).and_return([{
                'id': 'prefix-prod-myrepository'
            }])  # repo id
         .once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            ['prefix-prod-myrepository'],  # repo id
            wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
Example #14
0
    def test_delete_not_implemented(self, caplog):
        """
        Should log an error (but not raise an exception) when
        delete_from_registry is True.
        """
        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args(['redhat-prod-myrepository'], fields=['id'])
            .and_return([{'id': 'redhat-prod-myrepository'}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                delete_from_registry=True)

        plugin.run()

        errors = [record.getMessage() for record in caplog.records()
                  if record.levelname == 'ERROR']

        assert [message for message in errors
                if 'not implemented' in message]
    def test_workspace_updated(self, reactor_config_map):  # noqa
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())

        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append(
            {
                'name': PulpSyncPlugin.key,
            },
        )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }

        if reactor_config_map:
            workflow.plugin_workspace = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1,
                               'pulp': {'name': env,
                                        'auth': {'user': '', 'password': ''}}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                **kwargs)
        plugin.run()

        manifests = get_manifests_in_pulp_repository(workflow)
        assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
    def test_store_registry(self, already_exists, reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry,
                                                 server_side_sync=False)

        if reactor_config_map:
            workflow.plugin_workspace = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1,
                               'pulp': {'name': env,
                                        'auth': {'user': '', 'password': ''}}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_pulp_auth(self, tmpdir, cer_exists, key_exists,
                       reactor_config_map):
        pulp_secret_path = str(tmpdir)
        cer = pulp_secret_path + '/pulp.cer'
        key = pulp_secret_path + '/pulp.key'
        if cer_exists:
            open(cer, 'w').close()

        if key_exists:
            open(key, 'w').close()

        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                pulp_secret_path=pulp_secret_path)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        if cer_exists and key_exists:
            (flexmock(mockpulp).should_receive('set_certs').with_args(
                cer, key).once().ordered())
            (flexmock(mockpulp).should_receive('getRepos').with_args(
                [prefixed_pulp_repoid], fields=['id']).and_return([{
                    'id':
                    prefixed_pulp_repoid
                }]).once().ordered())
            (flexmock(mockpulp).should_receive('syncRepo').with_args(
                repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                    ([], [])).once().ordered())
            (flexmock(mockpulp).should_receive('crane').with_args(
                [prefixed_pulp_repoid], wait=True).once().ordered())
        else:
            (flexmock(mockpulp).should_receive('set_certs').never())
            (flexmock(mockpulp).should_receive('syncRepo').never())
            (flexmock(mockpulp).should_receive('crane').never())

        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        if cer_exists and key_exists:
            plugin.run()
        else:
            with pytest.raises(RuntimeError):
                plugin.run()
    def test_pulp_auth(self, tmpdir, cer_exists, key_exists):
        pulp_secret_path = str(tmpdir)
        cer = pulp_secret_path + "/pulp.cer"
        key = pulp_secret_path + "/pulp.key"
        if cer_exists:
            open(cer, "w").close()

        if key_exists:
            open(key, "w").close()

        docker_registry = "http://registry.example.com"
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "redhat-prod-myrepository"
        env = "pulp"
        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow([docker_repository]),
            pulp_registry_name=env,
            docker_registry=docker_registry,
            pulp_secret_path=pulp_secret_path,
        )

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive("login").never())
        if cer_exists and key_exists:
            (flexmock(mockpulp).should_receive("set_certs").with_args(cer, key).once().ordered())
            (
                flexmock(mockpulp)
                .should_receive("getRepos")
                .with_args([prefixed_pulp_repoid], fields=["id"])
                .and_return([{"id": prefixed_pulp_repoid}])
                .once()
                .ordered()
            )
            (
                flexmock(mockpulp)
                .should_receive("syncRepo")
                .with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
                .and_return(([], []))
                .once()
                .ordered()
            )
            (flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
        else:
            (flexmock(mockpulp).should_receive("set_certs").never())
            (flexmock(mockpulp).should_receive("syncRepo").never())
            (flexmock(mockpulp).should_receive("crane").never())

        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        if cer_exists and key_exists:
            plugin.run()
        else:
            with pytest.raises(RuntimeError):
                plugin.run()
    def test_auth_certs(self, tmpdir, cer_exists, key_exists, source_secret,
                        monkeypatch):
        pulp_secret_path = str(tmpdir)
        cer = pulp_secret_path + '/pulp.cer'
        key = pulp_secret_path + '/pulp.key'
        if cer_exists:
            open(cer, 'w').close()

        if key_exists:
            open(key, 'w').close()

        if source_secret:
            monkeypatch.setenv('SOURCE_SECRET_PATH', pulp_secret_path)
            pulp_secret_path = None
        else:
            monkeypatch.delenv('SOURCE_SECRET_PATH', raising=False)

        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                pulp_secret_path=pulp_secret_path)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        if cer_exists and key_exists:
            (flexmock(mockpulp).should_receive('set_certs').with_args(
                cer, key).once().ordered())
            (flexmock(mockpulp).should_receive('syncRepo').with_args(
                object,
                'prod-myrepository',  # pulp repository name
                config_file=object).and_return([{
                    'id':
                    'prefix-prod-myrepository'
                }])  # repo id
             .once().ordered())
            (flexmock(mockpulp).should_receive('crane').with_args(
                ['prefix-prod-myrepository'],  # repo id
                wait=True).once().ordered())
        else:
            (flexmock(mockpulp).should_receive('set_certs').never())
            (flexmock(mockpulp).should_receive('syncRepo').never())
            (flexmock(mockpulp).should_receive('crane').never())

        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        if cer_exists and key_exists:
            plugin.run()
        else:
            with pytest.raises(RuntimeError):
                plugin.run()
Example #20
0
    def test_pulp_repo_prefix(self,
                              get_prefix,
                              pulp_repo_prefix,
                              expected_prefix):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        pulp_repoid = 'prod-myrepository'
        prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
        env = 'pulp'
        kwargs = {}
        if pulp_repo_prefix:
            kwargs['pulp_repo_prefix'] = pulp_repo_prefix

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                **kwargs)

        mockpulp = MockPulp()
        if get_prefix:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_return(expected_prefix))
        else:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_raise(AttributeError))

        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_dockercfg(self, tmpdir, scheme, reactor_config_map):
        docker_registry = '{}://registry.example.com'.format(scheme)
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        user = '******'
        pw = 'pass'
        env = 'pulp'

        registry_secret = os.path.join(str(tmpdir), '.dockercfg')
        dockercfg = {
            'registry.example.com': {
                'username': user,
                'password': pw,
                'email': '*****@*****.**',
            },
        }

        with open(registry_secret, 'w') as fp:
            json.dump(dockercfg, fp)

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry,
                       basic_auth_username=user,
                       basic_auth_password=pw)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_publish(self, publish, has_pulp_push, should_publish, caplog):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        if should_publish:
            (flexmock(mockpulp).should_receive('crane').with_args(
                [prefixed_pulp_repoid], wait=True).once().ordered())
        else:
            (flexmock(mockpulp).should_receive('crane').never())

        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append({
            'name': PulpSyncPlugin.key,
        }, )
        if has_pulp_push:
            workflow.postbuild_plugins_conf.append(
                {
                    'name': PLUGIN_PULP_PUSH_KEY,
                }, )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }
        if publish is not None:
            kwargs['publish'] = publish

        plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)

        plugin.run()
        log_messages = [l.getMessage() for l in caplog.records()]

        for image in workflow.tag_conf.images:
            expected_log = 'image available at %s' % image.to_str()
            if should_publish:
                assert expected_log in log_messages
            else:
                assert expected_log not in log_messages
Example #23
0
    def test_pulp_repo_prefix(self,
                              get_prefix,
                              pulp_repo_prefix,
                              expected_prefix):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
        env = 'pulp'
        kwargs = {}
        if pulp_repo_prefix:
            kwargs['pulp_repo_prefix'] = pulp_repo_prefix

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                **kwargs)

        mockpulp = MockPulp()
        if get_prefix:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_return(expected_prefix))
        else:
            (flexmock(mockpulp)
                .should_receive('getPrefix')
                .with_args()
                .and_raise(AttributeError))

        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
Example #24
0
    def test_workspace_updated(self):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())

        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append(
            {
                'name': PulpSyncPlugin.key,
            },
        )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                **kwargs)

        plugin.run()

        manifests = get_manifests_in_pulp_repository(workflow)
        assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
Example #25
0
    def test_store_registry(self, already_exists):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry,
                                                 server_side_sync=False)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
Example #26
0
    def test_dockercfg(self, tmpdir, scheme):
        docker_registry = '{}://registry.example.com'.format(scheme)
        docker_repository = 'prod/myrepository'
        pulp_repoid = 'prod-myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        user = '******'
        pw = 'pass'
        env = 'pulp'

        registry_secret = os.path.join(str(tmpdir), '.dockercfg')
        dockercfg = {
            'registry.example.com': {
                'username': user,
                'password': pw,
                'email': '*****@*****.**',
            },
        }

        with open(registry_secret, 'w') as fp:
            json.dump(dockercfg, fp)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry,
                       basic_auth_username=user,
                       basic_auth_password=pw)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_create_missing_repo(self, reactor_config_map):  # noqa
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('createRepo')
            .with_args(prefixed_pulp_repoid, None,
                       registry_id=docker_repository,
                       prefix_with='redhat-')
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_store_registry(self, already_exists, reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env,
                                                 mockpulp.registry,
                                                 server_side_sync=False)

        if reactor_config_map:
            workflow.plugin_workspace = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1,
                               'pulp': {'name': env,
                                        'auth': {'user': '', 'password': ''}}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_dockercfg(self, tmpdir, scheme):
        docker_registry = "{}://registry.example.com".format(scheme)
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "redhat-prod-myrepository"
        user = "******"
        pw = "pass"
        env = "pulp"

        registry_secret = os.path.join(str(tmpdir), ".dockercfg")
        dockercfg = {"registry.example.com": {"username": user, "password": pw, "email": "*****@*****.**"}}

        with open(registry_secret, "w") as fp:
            json.dump(dockercfg, fp)

        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow([docker_repository]),
            pulp_registry_name=env,
            docker_registry=docker_registry,
            registry_secret_path=str(tmpdir),
        )

        mockpulp = MockPulp()
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args([prefixed_pulp_repoid], fields=["id"])
            .and_return([{"id": prefixed_pulp_repoid}])
            .once()
            .ordered()
        )
        (
            flexmock(mockpulp)
            .should_receive("syncRepo")
            .with_args(
                repo=prefixed_pulp_repoid, feed=docker_registry, basic_auth_username=user, basic_auth_password=pw
            )
            .and_return(([], []))
            .once()
            .ordered()
        )
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        plugin.run()
    def test_dockpulp_loglevel(self, fail, caplog, reactor_config_map):
        loglevel = 3

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args(['redhat-prod-myrepository'], fields=['id'])
            .and_return([{'id': 'redhat-prod-myrepository'}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        logger = flexmock()
        expectation = (logger
                       .should_receive('setLevel')
                       .with_args(loglevel)
                       .once())

        if fail:
            expectation.and_raise(ValueError)

        flexmock(PulpLogWrapper).should_receive('get_pulp_logger').and_return(logger).once()

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                dockpulp_loglevel=loglevel)
        plugin.run()

        errors = [record.getMessage() for record in caplog.records
                  if record.levelname == 'ERROR']

        if fail:
            assert len(errors) >= 1
        else:
            assert not errors
    def test_insecure_registry(self, insecure_registry, ssl_validation, reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                insecure_registry=insecure_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        sync_exp = flexmock(mockpulp).should_receive('syncRepo')
        if ssl_validation is None:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry)
        else:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry,
                                          ssl_validation=ssl_validation)

        (sync_exp
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
Example #32
0
    def test_dockercfg_registry_not_present(self, tmpdir):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        registry_secret = os.path.join(str(tmpdir), '.dockercfg')
        dockercfg = {
            'other-registry.example.com': {
                'username': '******',
                'password': '******',
                'email': '*****@*****.**',
            },
        }

        with open(registry_secret, 'w') as fp:
            json.dump(dockercfg, fp)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
    def test_workspace_updated(self, reactor_config_map):  # noqa
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())

        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append({
            'name': PulpSyncPlugin.key,
        }, )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }

        if reactor_config_map:
            workflow.plugin_workspace = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1,
                               'pulp': {'name': env,
                                        'auth': {'user': '', 'password': ''}}})

        plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)
        plugin.run()

        manifests = get_manifests_in_pulp_repository(workflow)
        assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
    def test_store_registry(self, already_exists):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(object,
                       'prod-myrepository',  # pulp repository name
                       config_file=object)
            .and_return([{'id': 'prefix-prod-myrepository'}])  # repo id
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args(['prefix-prod-myrepository'],  # repo id
                       wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_pulp_repo_prefix(self, get_prefix, pulp_repo_prefix, expected_prefix):
        docker_registry = "http://registry.example.com"
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "{}prod-myrepository".format(expected_prefix)
        env = "pulp"
        kwargs = {}
        if pulp_repo_prefix:
            kwargs["pulp_repo_prefix"] = pulp_repo_prefix

        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow([docker_repository]),
            pulp_registry_name=env,
            docker_registry=docker_registry,
            **kwargs
        )

        mockpulp = MockPulp()
        if get_prefix:
            (flexmock(mockpulp).should_receive("getPrefix").with_args().and_return(expected_prefix))
        else:
            (flexmock(mockpulp).should_receive("getPrefix").with_args().and_raise(AttributeError))

        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args([prefixed_pulp_repoid], fields=["id"])
            .and_return([{"id": prefixed_pulp_repoid}])
            .once()
            .ordered()
        )
        (
            flexmock(mockpulp)
            .should_receive("syncRepo")
            .with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered()
        )
        (flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        plugin.run()
    def test_pulp_repo_prefix(self, get_prefix, pulp_repo_prefix,
                              expected_prefix, reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
        env = 'pulp'
        kwargs = {}
        if pulp_repo_prefix:
            kwargs['pulp_repo_prefix'] = pulp_repo_prefix

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                **kwargs)

        mockpulp = MockPulp()
        if get_prefix:
            (flexmock(mockpulp).should_receive(
                'getPrefix').with_args().and_return(expected_prefix))
        else:
            (flexmock(mockpulp).should_receive(
                'getPrefix').with_args().and_raise(AttributeError))

        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
    def test_dockercfg_registry_not_present(self, tmpdir,
                                            reactor_config_map):  # noqa
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        registry_secret = os.path.join(str(tmpdir), '.dockercfg')
        dockercfg = {
            'other-registry.example.com': {
                'username': '******',
                'password': '******',
                'email': '*****@*****.**',
            },
        }

        with open(registry_secret, 'w') as fp:
            json.dump(dockercfg, fp)

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
Example #38
0
    def test_print_availability_info(self, has_pulp_push, caplog):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        pulp_repoid = 'prod-myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('login').never())
        (flexmock(mockpulp).should_receive('set_certs').never())
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append({'name': PulpSyncPlugin.key})
        if has_pulp_push:
            # PulpPushPlugin.key is not imported here to avoid circular import
            workflow.postbuild_plugins_conf.append({'name': 'pulp_push'})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        plugin.run()
        log_messages = [l.getMessage() for l in caplog.records()]

        for image in workflow.tag_conf.images:
            expected_log = 'image available at %s' % image.to_str()
            if has_pulp_push:
                assert expected_log not in log_messages
            else:
                assert expected_log in log_messages
    def test_dockpulp_loglevel(self, fail, caplog, reactor_config_map):
        loglevel = 3

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            ['redhat-prod-myrepository'], fields=['id']).and_return([{
                'id':
                'redhat-prod-myrepository'
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        logger = flexmock()
        expectation = (
            logger.should_receive('setLevel').with_args(loglevel).once())

        if fail:
            expectation.and_raise(ValueError)

        flexmock(PulpLogWrapper).should_receive('get_pulp_logger').and_return(
            logger).once()

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                dockpulp_loglevel=loglevel)
        plugin.run()

        errors = [
            record.getMessage() for record in caplog.records()
            if record.levelname == 'ERROR'
        ]

        if fail:
            assert len(errors) >= 1
        else:
            assert not errors
    def test_auth_password(self):
        username = '******'
        password = '******'
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                username=username,
                                password=password)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .with_args(username, password)
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(object,
                       'prod-myrepository',  # pulp repository name
                       config_file=object)
            .and_return([{'id': 'prefix-prod-myrepository'}])  # repo id
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args(['prefix-prod-myrepository'],  # repo id
                       wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
Example #41
0
    def test_dockpulp_loglevel(self, fail, caplog):
        loglevel = 3

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args(['redhat-prod-myrepository'], fields=['id'])
            .and_return([{'id': 'redhat-prod-myrepository'}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        logger = flexmock()
        expectation = (logger
                       .should_receive('setLevel')
                       .with_args(loglevel)
                       .once())
        if fail:
            expectation.and_raise(ValueError)

        (flexmock(dockpulp)
            .should_receive('setup_logger')
            .and_return(logger)
            .once())

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                dockpulp_loglevel=loglevel)

        plugin.run()

        errors = [record.getMessage() for record in caplog.records()
                  if record.levelname == 'ERROR']

        if fail:
            assert len(errors) >= 1
        else:
            assert not errors
Example #42
0
    def test_auth_none(self):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('crane')
            .with_args([prefixed_pulp_repoid], wait=True)
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
Example #43
0
    def test_dockpulp_loglevel(self, fail, caplog):
        loglevel = 3

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args(['redhat-prod-myrepository'], fields=['id'])
            .and_return([{'id': 'redhat-prod-myrepository'}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .and_return(([], [])))
        flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
        logger = flexmock()
        expectation = (logger
                       .should_receive('setLevel')
                       .with_args(loglevel)
                       .once())
        if fail:
            expectation.and_raise(ValueError)

        (flexmock(dockpulp)
            .should_receive('setup_logger')
            .and_return(logger)
            .once())

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['prod/myrepository']),
                                pulp_registry_name='pulp',
                                docker_registry='http://registry.example.com',
                                dockpulp_loglevel=loglevel)

        plugin.run()

        errors = [record.getMessage() for record in caplog.records()
                  if record.levelname == 'ERROR']

        if fail:
            assert len(errors) >= 1
        else:
            assert not errors
    def test_dockercfg_missing_or_invalid(self, tmpdir, content):
        env = 'pulp'

        if content is not None:
            registry_secret = os.path.join(str(tmpdir), '.dockercfg')
            with open(registry_secret, 'w') as fp:
                fp.write(content)

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow(['repo']),
                                pulp_registry_name=env,
                                docker_registry='http://registry.example.com',
                                registry_secret_path=str(tmpdir))

        mockpulp = MockPulp()
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        with pytest.raises(RuntimeError):
            plugin.run()
    def test_create_missing_repo(self):
        docker_registry = "http://registry.example.com"
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "redhat-prod-myrepository"
        env = "pulp"
        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow([docker_repository]),
            pulp_registry_name=env,
            docker_registry=docker_registry,
        )

        mockpulp = MockPulp()
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args([prefixed_pulp_repoid], fields=["id"])
            .and_return([])
            .once()
            .ordered()
        )
        (
            flexmock(mockpulp)
            .should_receive("createRepo")
            .with_args(prefixed_pulp_repoid, None, registry_id=docker_repository, prefix_with="redhat-")
            .once()
            .ordered()
        )
        (
            flexmock(mockpulp)
            .should_receive("syncRepo")
            .with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered()
        )
        (flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        plugin.run()
    def test_dockercfg_missing_or_invalid(self, tmpdir, content):
        env = "pulp"

        if content is not None:
            registry_secret = os.path.join(str(tmpdir), ".dockercfg")
            with open(registry_secret, "w") as fp:
                fp.write(content)

        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow(["repo"]),
            pulp_registry_name=env,
            docker_registry="http://registry.example.com",
            registry_secret_path=str(tmpdir),
        )

        mockpulp = MockPulp()
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        with pytest.raises(RuntimeError):
            plugin.run()
    def test_store_registry(self, already_exists):
        docker_registry = "http://registry.example.com"
        docker_repository = "prod/myrepository"
        pulp_repoid = "prod-myrepository"
        prefixed_pulp_repoid = "redhat-prod-myrepository"
        env = "pulp"
        workflow = self.workflow([docker_repository])

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive("login").never())
        (flexmock(mockpulp).should_receive("set_certs").never())
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args([prefixed_pulp_repoid], fields=["id"])
            .and_return([{"id": prefixed_pulp_repoid}])
            .once()
            .ordered()
        )
        (
            flexmock(mockpulp)
            .should_receive("syncRepo")
            .with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered()
        )
        (flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
        (flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))

        if already_exists:
            workflow.push_conf.add_pulp_registry(env, mockpulp.registry)

        plugin = PulpSyncPlugin(tasker=None, workflow=workflow, pulp_registry_name=env, docker_registry=docker_registry)

        num_registries = len(workflow.push_conf.pulp_registries)
        assert num_registries == (1 if already_exists else 0)
        plugin.run()
        assert len(workflow.push_conf.pulp_registries) == 1
    def test_insecure_registry(self, insecure_registry, ssl_validation,
                               reactor_config_map):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        if reactor_config_map:
            self.workflow.plugin_workspace = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
            self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
                ReactorConfig({'version': 1, 'pulp': {'name': env}})

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                insecure_registry=insecure_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        sync_exp = flexmock(mockpulp).should_receive('syncRepo')
        if ssl_validation is None:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry)
        else:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry,
                                          ssl_validation=ssl_validation)

        (sync_exp.and_return(([], [])).once().ordered())
        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        plugin.run()
    def test_workspace_updated(self):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp).should_receive('getRepos').with_args(
            [prefixed_pulp_repoid], fields=['id']).and_return([{
                'id':
                prefixed_pulp_repoid
            }]).once().ordered())
        (flexmock(mockpulp).should_receive('syncRepo').with_args(
            repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
                ([], [])).once().ordered())
        (flexmock(mockpulp).should_receive('crane').with_args(
            [prefixed_pulp_repoid], wait=True).once().ordered())

        (flexmock(dockpulp).should_receive('Pulp').with_args(
            env=env).and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append({
            'name': PulpSyncPlugin.key,
        }, )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }

        plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)

        plugin.run()

        manifests = get_manifests_in_pulp_repository(workflow)
        assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
    def test_dockpulp_loglevel(self, fail, caplog):
        loglevel = 3

        mockpulp = MockPulp()
        (
            flexmock(mockpulp)
            .should_receive("getRepos")
            .with_args(["redhat-prod-myrepository"], fields=["id"])
            .and_return([{"id": "redhat-prod-myrepository"}])
            .once()
            .ordered()
        )
        (flexmock(mockpulp).should_receive("syncRepo").and_return(([], [])))
        flexmock(dockpulp).should_receive("Pulp").and_return(mockpulp)
        logger = flexmock()
        expectation = logger.should_receive("setLevel").with_args(loglevel).once()
        if fail:
            expectation.and_raise(ValueError)

        (flexmock(dockpulp).should_receive("setup_logger").and_return(logger).once())

        plugin = PulpSyncPlugin(
            tasker=None,
            workflow=self.workflow(["prod/myrepository"]),
            pulp_registry_name="pulp",
            docker_registry="http://registry.example.com",
            dockpulp_loglevel=loglevel,
        )

        plugin.run()

        errors = [record.getMessage() for record in caplog.records() if record.levelname == "ERROR"]

        if fail:
            assert len(errors) >= 1
        else:
            assert not errors
Example #51
0
    def test_insecure_registry(self, insecure_registry, ssl_validation):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                insecure_registry=insecure_registry)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        sync_exp = flexmock(mockpulp).should_receive('syncRepo')
        if ssl_validation is None:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry)
        else:
            sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
                                          feed=docker_registry,
                                          ssl_validation=ssl_validation)

        (sync_exp
            .and_return(([], []))
            .once()
            .ordered())
        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        plugin.run()
Example #52
0
    def test_pulp_auth(self, tmpdir, cer_exists, key_exists):
        pulp_secret_path = str(tmpdir)
        cer = pulp_secret_path + '/pulp.cer'
        key = pulp_secret_path + '/pulp.key'
        if cer_exists:
            open(cer, 'w').close()

        if key_exists:
            open(key, 'w').close()

        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                pulp_secret_path=pulp_secret_path)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        if cer_exists and key_exists:
            (flexmock(mockpulp)
                .should_receive('set_certs')
                .with_args(cer, key)
                .once()
                .ordered())
            (flexmock(mockpulp)
                .should_receive('getRepos')
                .with_args([prefixed_pulp_repoid], fields=['id'])
                .and_return([{'id': prefixed_pulp_repoid}])
                .once()
                .ordered())
            (flexmock(mockpulp)
                .should_receive('syncRepo')
                .with_args(repo=prefixed_pulp_repoid,
                           feed=docker_registry)
                .and_return(([], []))
                .once()
                .ordered())
            (flexmock(mockpulp)
                .should_receive('crane')
                .with_args([prefixed_pulp_repoid], wait=True)
                .once()
                .ordered())
        else:
            (flexmock(mockpulp)
                .should_receive('set_certs')
                .never())
            (flexmock(mockpulp)
                .should_receive('syncRepo')
                .never())
            (flexmock(mockpulp)
                .should_receive('crane')
                .never())

        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        if cer_exists and key_exists:
            plugin.run()
        else:
            with pytest.raises(RuntimeError):
                plugin.run()
Example #53
0
    def test_publish(self, publish, has_pulp_push, should_publish, caplog):
        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        prefixed_pulp_repoid = 'redhat-prod-myrepository'
        env = 'pulp'

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        (flexmock(mockpulp)
            .should_receive('set_certs')
            .never())
        (flexmock(mockpulp)
            .should_receive('getRepos')
            .with_args([prefixed_pulp_repoid], fields=['id'])
            .and_return([{'id': prefixed_pulp_repoid}])
            .once()
            .ordered())
        (flexmock(mockpulp)
            .should_receive('syncRepo')
            .with_args(repo=prefixed_pulp_repoid,
                       feed=docker_registry)
            .and_return(([], []))
            .once()
            .ordered())
        if should_publish:
            (flexmock(mockpulp)
                .should_receive('crane')
                .with_args([prefixed_pulp_repoid], wait=True)
                .once()
                .ordered())
        else:
            (flexmock(mockpulp)
                .should_receive('crane')
                .never())

        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        workflow = self.workflow([docker_repository], mockpulp.registry)
        workflow.postbuild_plugins_conf.append(
            {
                'name': PulpSyncPlugin.key,
            },
        )
        if has_pulp_push:
            workflow.postbuild_plugins_conf.append(
                {
                    'name': PLUGIN_PULP_PUSH_KEY,
                },
            )

        kwargs = {
            'pulp_registry_name': env,
            'docker_registry': docker_registry,
        }
        if publish is not None:
            kwargs['publish'] = publish

        plugin = PulpSyncPlugin(tasker=None,
                                workflow=workflow,
                                **kwargs)

        plugin.run()
        log_messages = [l.getMessage() for l in caplog.records()]

        for image in workflow.tag_conf.images:
            expected_log = 'image available at %s' % image.to_str()
            if should_publish:
                assert expected_log in log_messages
            else:
                assert expected_log not in log_messages
    def test_auth_certs(self, tmpdir, cer_exists, key_exists, source_secret, monkeypatch):
        pulp_secret_path = str(tmpdir)
        cer = pulp_secret_path + '/pulp.cer'
        key = pulp_secret_path + '/pulp.key'
        if cer_exists:
            open(cer, 'w').close()

        if key_exists:
            open(key, 'w').close()

        if source_secret:
            monkeypatch.setenv('SOURCE_SECRET_PATH', pulp_secret_path)
            pulp_secret_path = None
        else:
            monkeypatch.delenv('SOURCE_SECRET_PATH', raising=False)

        docker_registry = 'http://registry.example.com'
        docker_repository = 'prod/myrepository'
        env = 'pulp'
        plugin = PulpSyncPlugin(tasker=None,
                                workflow=self.workflow([docker_repository]),
                                pulp_registry_name=env,
                                docker_registry=docker_registry,
                                pulp_secret_path=pulp_secret_path)

        mockpulp = MockPulp()
        (flexmock(mockpulp)
            .should_receive('login')
            .never())
        if cer_exists and key_exists:
            (flexmock(mockpulp)
                .should_receive('set_certs')
                .with_args(cer, key)
                .once()
                .ordered())
            (flexmock(mockpulp)
                .should_receive('syncRepo')
                .with_args(object,
                           'prod-myrepository',  # pulp repository name
                           config_file=object)
                .and_return([{'id': 'prefix-prod-myrepository'}])  # repo id
                .once()
                .ordered())
            (flexmock(mockpulp)
                .should_receive('crane')
                .with_args(['prefix-prod-myrepository'],  # repo id
                           wait=True)
                .once()
                .ordered())
        else:
            (flexmock(mockpulp)
                .should_receive('set_certs')
                .never())
            (flexmock(mockpulp)
                .should_receive('syncRepo')
                .never())
            (flexmock(mockpulp)
                .should_receive('crane')
                .never())

        (flexmock(dockpulp)
            .should_receive('Pulp')
            .with_args(env=env)
            .and_return(mockpulp))

        if cer_exists and key_exists:
            plugin.run()
        else:
            with pytest.raises(RuntimeError):
                plugin.run()