def workflow(self, push=True, sync=True, build_process_failed=False,
                 postbuild_results=None, prebuild_results=None, expectv2schema2=False,
                 platform_descriptors=False):
        tag_conf = TagConf()
        tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)
        push_conf = PushConf()
        if push:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=False)
        if sync:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=True)

        conf = {
            ReactorConfigKeys.VERSION_KEY: 1,
            'prefer_schema1_digest': not expectv2schema2
        }
        if platform_descriptors:
            conf['platform_descriptors'] = [
                {'platform': 'x86_64', 'architecture': 'amd64'},
            ]
        plugin_workspace = {
            ReactorConfigPlugin.key: {
                WORKSPACE_CONF_KEY: ReactorConfig(conf)
            }
        }

        mock_get_retry_session()
        builder = flexmock()
        setattr(builder, 'image_id', 'sha256:(old)')
        return flexmock(tag_conf=tag_conf,
                        push_conf=push_conf,
                        builder=builder,
                        build_process_failed=build_process_failed,
                        plugin_workspace=plugin_workspace,
                        postbuild_results=postbuild_results or {},
                        prebuild_results=prebuild_results or {})
Пример #2
0
    def workflow(self, push=True, sync=True, build_process_failed=False,
                 postbuild_results=None, prebuild_results=None, expectv2schema2=False,
                 platform_descriptors=False):
        tag_conf = TagConf()
        tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)
        push_conf = PushConf()
        if push:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=False)
        if sync:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=True)

        conf = {
            ReactorConfigKeys.VERSION_KEY: 1,
            'prefer_schema1_digest': not expectv2schema2
        }
        if platform_descriptors:
            conf['platform_descriptors'] = [
                {'platform': 'x86_64', 'architecture': 'amd64'},
            ]
        plugin_workspace = {
            ReactorConfigPlugin.key: {
                WORKSPACE_CONF_KEY: ReactorConfig(conf)
            }
        }

        mock_get_retry_session()
        builder = flexmock()
        setattr(builder, 'image_id', 'sha256:(old)')
        return flexmock(tag_conf=tag_conf,
                        push_conf=push_conf,
                        builder=builder,
                        build_process_failed=build_process_failed,
                        plugin_workspace=plugin_workspace,
                        postbuild_results=postbuild_results or {},
                        prebuild_results=prebuild_results or {})
Пример #3
0
    def test_get_unique_images_with_platform(self):
        image = 'registry.com/org/hello:world-16111-20220103213046'
        platform = 'x86_64'

        tag_conf = TagConf()
        tag_conf.add_unique_image(image)

        expected = [ImageName.parse(f'{image}-{platform}')]
        actual = tag_conf.get_unique_images_with_platform(platform)

        assert actual == expected
Пример #4
0
 def workflow(self):
     tag_conf = TagConf()
     tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)
     push_conf = PushConf()
     push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI)
     builder = flexmock()
     setattr(builder, 'image_id', 'sha256:(old)')
     return flexmock(tag_conf=tag_conf,
                     push_conf=push_conf,
                     builder=builder,
                     plugin_workspace={})
Пример #5
0
    def workflow(self, push=True, sync=True, build_process_failed=False):
        tag_conf = TagConf()
        tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)
        push_conf = PushConf()
        if push:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=False)
        if sync:
            push_conf.add_pulp_registry('pulp', crane_uri=self.CRANE_URI, server_side_sync=True)

        mock_get_retry_session()
        builder = flexmock()
        setattr(builder, 'image_id', 'sha256:(old)')
        return flexmock(tag_conf=tag_conf,
                        push_conf=push_conf,
                        builder=builder,
                        build_process_failed=build_process_failed,
                        plugin_workspace={})
    def workflow(self,
                 build_process_failed=False,
                 registries=None,
                 registry_types=None,
                 platforms=None,
                 platform_descriptors=None,
                 group=True,
                 fail=False,
                 limit_media_types=None):
        tag_conf = TagConf()
        tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)

        if platform_descriptors is None:
            platform_descriptors = [
                {
                    'platform': 'x86_64',
                    'architecture': 'amd64'
                },
                {
                    'platform': 'ppc64le',
                    'architecture': 'ppc64le'
                },
                {
                    'platform': 's390x',
                    'architecture': 's390x'
                },
            ]

        if platforms is None:
            platforms = [
                descriptor['platform'] for descriptor in platform_descriptors
            ]
        no_amd64 = 'x86_64' not in platforms

        keep_types = False
        if registries or registry_types:
            keep_types = True

        if registries is None and registry_types is None:
            registry_types = [
                MEDIA_TYPE_DOCKER_V2_SCHEMA1, MEDIA_TYPE_DOCKER_V2_SCHEMA2,
                MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST, MEDIA_TYPE_OCI_V1,
                MEDIA_TYPE_OCI_V1_INDEX
            ]

        if registries is None:
            registries = [{
                'url': 'https://container-registry.example.com/v2',
                'version': 'v2',
                'insecure': True,
                'expected_media_types': registry_types
            }]
        conf = {
            'version': 1,
            'registries': registries,
        }

        if limit_media_types is not None:
            conf['source_container'] = {
                'limit_media_types': limit_media_types,
            }

        if platform_descriptors:
            conf['platform_descriptors'] = platform_descriptors

        for registry in registries:

            def get_manifest(request):
                media_types = request.headers.get('Accept', '').split(',')
                content_type = media_types[0]

                return 200, {'Content-Type': content_type}, '{}'

            url_regex = "r'" + registry['url'] + ".*/manifests/.*'"
            url = re.compile(url_regex)
            responses.add_callback(responses.GET, url, callback=get_manifest)

            expected_types = registry.get('expected_media_types',
                                          registry_types or [])
            if fail == "bad_results":
                response_types = []
            elif not keep_types and no_amd64:
                response_types = [MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST]
            else:
                response_types = expected_types

            reguri = RegistryURI(registry['url']).docker_uri
            if re.match('http(s)?://', reguri):
                urlbase = reguri
            else:
                urlbase = 'https://{0}'.format(reguri)

            actual_v2_url = urlbase + "/v2/foo/manifests/unique-tag"

            if fail == "bad_results":
                response = requests.Response()
                (flexmock(response,
                          raise_for_status=lambda: None,
                          status_code=requests.codes.ok,
                          json={},
                          headers={'Content-Type': 'application/json'}))
                v1_response = response
                v1_oci_response = response
                v1_oci_index_response = response
                v2_response = response
                v2_list_response = response
            else:
                v1_response = self.config_response_none
                v1_oci_response = self.config_response_none
                v1_oci_index_response = self.config_response_none
                v2_response = self.config_response_none
                v2_list_response = self.config_response_none

            if MEDIA_TYPE_DOCKER_V2_SCHEMA1 in response_types:
                v1_response = self.config_response_config_v1
            if MEDIA_TYPE_DOCKER_V2_SCHEMA2 in response_types:
                v2_response = self.config_response_config_v2
            if MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST in response_types:
                v2_list_response = self.config_response_config_v2_list
            if MEDIA_TYPE_OCI_V1 in response_types:
                v1_oci_response = self.config_response_config_oci_v1
            if MEDIA_TYPE_OCI_V1_INDEX in response_types:
                v1_oci_index_response = self.config_response_config_oci_v1_index

            v2_header_v1 = {'Accept': MEDIA_TYPE_DOCKER_V2_SCHEMA1}
            v2_header_v2 = {'Accept': MEDIA_TYPE_DOCKER_V2_SCHEMA2}
            manifest_header = {'Accept': MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST}

            (flexmock(requests.Session).should_receive('get').with_args(
                actual_v2_url,
                headers=v2_header_v1,
                auth=HTTPRegistryAuth,
                verify=False).and_return(v1_response))
            (flexmock(requests.Session).should_receive('get').with_args(
                actual_v2_url,
                headers=v2_header_v2,
                auth=HTTPRegistryAuth,
                verify=False).and_return(v2_response))
            (flexmock(requests.Session).should_receive('get').with_args(
                actual_v2_url,
                headers={
                    'Accept': MEDIA_TYPE_OCI_V1
                },
                auth=HTTPRegistryAuth,
                verify=False).and_return(v1_oci_response))
            (flexmock(requests.Session).should_receive('get').with_args(
                actual_v2_url,
                headers={
                    'Accept': MEDIA_TYPE_OCI_V1_INDEX
                },
                auth=HTTPRegistryAuth,
                verify=False).and_return(v1_oci_index_response))
            (flexmock(requests.Session).should_receive('get').with_args(
                actual_v2_url,
                headers=manifest_header,
                auth=HTTPRegistryAuth,
                verify=False).and_return(v2_list_response))

        digests = {'media_type': MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST}
        if not group:
            digests = {'media_type': MEDIA_TYPE_DOCKER_V2_SCHEMA2}
        plugins_results = {
            PLUGIN_CHECK_AND_SET_PLATFORMS_KEY: platforms,
            PLUGIN_GROUP_MANIFESTS_KEY: digests,
        }

        mock_get_retry_session()
        builder = flexmock()
        setattr(builder, 'image_id', 'sha256:(old)')

        flexmock(tag_conf=tag_conf)
        wf_data = ImageBuildWorkflowData()
        wf_data.tag_conf = tag_conf
        wf_data.plugins_results = plugins_results

        return flexmock(data=wf_data,
                        builder=builder,
                        conf=Configuration(raw_config=conf),
                        build_process_failed=build_process_failed)
    def workflow(self, build_process_failed=False, registries=None, registry_types=None,
                 platforms=None, platform_descriptors=None, group=True, no_amd64=False,
                 fail=False):
        tag_conf = TagConf()
        tag_conf.add_unique_image(self.TEST_UNIQUE_IMAGE)

        push_conf = PushConf()

        if platform_descriptors is None:
            platform_descriptors = [
                {'platform': 'x86_64', 'architecture': 'amd64'},
                {'platform': 'ppc64le', 'architecture': 'ppc64le'},
                {'platform': 's390x', 'architecture': 's390x'},
            ]

        if platforms is None:
            platforms = [descriptor['platform'] for descriptor in platform_descriptors]

        if registries is None and registry_types is None:
            registry_types = [MEDIA_TYPE_DOCKER_V1, MEDIA_TYPE_DOCKER_V2_SCHEMA1,
                              MEDIA_TYPE_DOCKER_V2_SCHEMA2, MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST]

        if registries is None:
            registries = [{
                'url': 'https://container-registry.example.com/v2',
                'version': 'v2',
                'insecure': True,
                'expected_media_types': registry_types
            }]
        conf = {
            ReactorConfigKeys.VERSION_KEY: 1,
            'registries': registries,
        }
        if platform_descriptors:
            conf['platform_descriptors'] = platform_descriptors

        plugin_workspace = {
            ReactorConfigPlugin.key: {
                WORKSPACE_CONF_KEY: ReactorConfig(conf)
            }
        }

        flexmock(HTTPRegistryAuth).should_receive('__new__').and_return(None)
        mock_auth = None
        for registry in registries:
            def get_manifest(request):
                media_types = request.headers.get('Accept', '').split(',')
                content_type = media_types[0]

                return (200, {'Content-Type': content_type}, '{}')

            url_regex = "r'" + registry['url'] + ".*/manifests/.*'"
            url = re.compile(url_regex)
            responses.add_callback(responses.GET, url, callback=get_manifest)

            expected_types = registry.get('expected_media_types', [])
            if fail == "bad_results":
                response_types = [MEDIA_TYPE_DOCKER_V1]
            elif no_amd64:
                response_types = [MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST]
            else:
                response_types = expected_types

            reguri = RegistryURI(registry['url']).docker_uri
            if re.match('http(s)?://', reguri):
                urlbase = reguri
            else:
                urlbase = 'https://{0}'.format(reguri)

            actual_v2_url = urlbase + "/v2/foo/manifests/unique-tag"
            actual_v1_url = urlbase + "/v1/repositories/foo/tags/unique-tag"

            v1_response = self.config_response_none
            v2_response = self.config_response_none
            v2_list_response = self.config_response_none
            if MEDIA_TYPE_DOCKER_V2_SCHEMA1 in response_types:
                v1_response = self.config_response_config_v1
            if MEDIA_TYPE_DOCKER_V2_SCHEMA2 in response_types:
                v2_response = self.config_response_config_v2
            if MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST in response_types:
                v2_list_response = self.config_response_config_v2_list
            v2_header_v1 = {'Accept': MEDIA_TYPE_DOCKER_V2_SCHEMA1}
            v2_header_v2 = {'Accept': MEDIA_TYPE_DOCKER_V2_SCHEMA2}
            manifest_header = {'Accept': MEDIA_TYPE_DOCKER_V2_MANIFEST_LIST}

            (flexmock(requests.Session)
                .should_receive('get')
                .with_args(actual_v2_url, headers=v2_header_v1,
                           auth=mock_auth, verify=False)
                .and_return(v1_response))
            (flexmock(requests.Session)
                .should_receive('get')
                .with_args(actual_v2_url, headers=v2_header_v2,
                           auth=mock_auth, verify=False)
                .and_return(v2_response))
            (flexmock(requests.Session)
                .should_receive('get')
                .with_args(actual_v2_url, headers={'Accept': MEDIA_TYPE_OCI_V1},
                           auth=mock_auth, verify=False)
                .and_return(self.config_response_none))
            (flexmock(requests.Session)
                .should_receive('get')
                .with_args(actual_v2_url, headers={'Accept': MEDIA_TYPE_OCI_V1_INDEX},
                           auth=mock_auth, verify=False)
                .and_return(self.config_response_none))
            (flexmock(requests.Session)
                .should_receive('get')
                .with_args(actual_v2_url, headers=manifest_header,
                           auth=mock_auth, verify=False)
                .and_return(v2_list_response))

            if MEDIA_TYPE_DOCKER_V1 in response_types:
                (flexmock(requests.Session)
                    .should_receive('get')
                    .with_args(actual_v1_url, headers={'Accept': MEDIA_TYPE_DOCKER_V1},
                               auth=mock_auth, verify=False)
                    .and_return(self.config_response_v1))

        digests = {'digest': None} if group else {}
        prebuild_results = {PLUGIN_CHECK_AND_SET_PLATFORMS_KEY: platforms}
        postbuild_results = {PLUGIN_GROUP_MANIFESTS_KEY: digests}

        mock_get_retry_session()
        builder = flexmock()
        setattr(builder, 'image_id', 'sha256:(old)')
        return flexmock(tag_conf=tag_conf,
                        push_conf=push_conf,
                        builder=builder,
                        build_process_failed=build_process_failed,
                        plugin_workspace=plugin_workspace,
                        prebuild_results=prebuild_results,
                        postbuild_results=postbuild_results)