예제 #1
0
    def process_request(req):
        """Process api request:
        1. Define if this is request for available versions or not
        2. If it is not version request check extract version
        3. Validate available version and add version info to request
        """

        args = {'method': req.method, 'path': req.path, 'accept': req.accept}
        LOG.debug(
            "Determining version of request: %(method)s %(path)s "
            "Accept: %(accept)s", args)

        # determine if this is request for versions
        if req.path_info in ('/versions', '/'):
            return artifacts_versions.Controller.index(req)

        # determine api version from request
        req_version = GlareVersionNegotiationFilter.get_version_from_accept(
            req.accept)
        if req_version is None:
            # determine api version from microversion header
            LOG.debug("Determine version from microversion header.")
            req_version = microversion_parse.get_version(
                req.headers,
                service_type=GlareVersionNegotiationFilter.SERVICE_TYPE)

        # validate microversions header
        req.api_version_request = \
            GlareVersionNegotiationFilter._get_api_version_request(
                req_version)
        req_version = req.api_version_request.get_string()

        LOG.debug("Matched version: %s", req_version)
        LOG.debug('new path %s', req.path_info)
예제 #2
0
파일: base.py 프로젝트: sainusahib/cyborg
    def parse_headers(headers, default_version, latest_version):
        """Determine the API version requested based on the headers supplied.

        :param headers: webob headers
        :param default_version: version to use if not specified in headers
        :param latest_version: version to use if latest is requested
        :returns: a tuple of (major, minor) version numbers
        :raises: webob.HTTPNotAcceptable

        """
        version_str = microversion_parse.get_version(
            headers, service_type='accelerator')

        minimal_version = (2, 0)

        if version_str is None:
            # If requested header is wrong, Cyborg answers with the minimal
            # supported version.
            return minimal_version

        if version_str.lower() == 'latest':
            parse_str = latest_version
        else:
            parse_str = version_str

        try:
            version = tuple(int(i) for i in parse_str.split('.'))
        except ValueError:
            version = minimal_version

        if len(version) != 2:
            raise exc.HTTPNotAcceptable("Invalid value for %s header" %
                                        Version.current_api_version)
        return version
예제 #3
0
    def _check_version_request(self, req, controller):
        """Set API version request based on the request header and controller.

        :param req: The webob.Request object.
        :param controller: The API version controller.
        :returns: ``None``
        :raises: ``HTTPBadRequest`` if API version string is bad.
        """
        api_version = mp.get_version(req.headers, service_type='clustering')
        if api_version is None:
            api_version = controller.DEFAULT_API_VERSION
        elif api_version.lower() == 'latest':
            req.version_request = controller.max_api_version()
            return

        try:
            ver = vr.APIVersionRequest(api_version)
        except exception.InvalidAPIVersionString as e:
            raise webob.exc.HTTPBadRequest(six.text_type(e))

        if not ver.matches(controller.min_api_version(),
                           controller.max_api_version()):
            raise exception.InvalidGlobalAPIVersion(
                req_ver=api_version,
                min_ver=six.text_type(controller.min_api_version()),
                max_ver=six.text_type(controller.max_api_version()))

        req.version_request = ver
 def test_capitalized_headers(self):
     headers = {'X-Openstack-Ironic-Api-Version': '123.456'}
     version = microversion_parse.get_version(
         headers,
         service_type='ironic',
         legacy_headers=['X-Openstack-Ironic-Api-Version'])
     self.assertEqual('123.456', version)
예제 #5
0
    def set_api_version_request(self):
        """Set API version request based on the request header information."""
        hdr_string = microversion_parse.get_version(
            self.headers, service_type='compute',
            legacy_headers=[LEGACY_API_VERSION_REQUEST_HEADER])

        if hdr_string is None:
            self.api_version_request = api_version.APIVersionRequest(
                api_version.DEFAULT_API_VERSION)
        elif hdr_string == 'latest':
            # 'latest' is a special keyword which is equivalent to
            # requesting the maximum version of the API supported
            self.api_version_request = api_version.max_api_version()
        else:
            self.api_version_request = api_version.APIVersionRequest(
                hdr_string)

            # Check that the version requested is within the global
            # minimum/maximum of supported API versions
            if not self.api_version_request.matches(
                    api_version.min_api_version(),
                    api_version.max_api_version()):
                raise exception.InvalidGlobalAPIVersion(
                    req_ver=self.api_version_request.get_string(),
                    min_ver=api_version.min_api_version().get_string(),
                    max_ver=api_version.max_api_version().get_string())
 def test_get_version_from_environ(self):
     environ = {'PATH_INFO': '/foo/bar',
                'HTTP_OPENSTACK_API_VERSION': 'placement 2.1',
                'HTTP_CONTENT_TYPE': 'application/json'}
     expected_version = '2.1'
     headers = microversion_parse.headers_from_wsgi_environ(environ)
     version = microversion_parse.get_version(headers, 'placement')
     self.assertEqual(expected_version, version)
예제 #7
0
파일: api.py 프로젝트: wuhsh/sahara
def get_requested_microversion():
    requested_version = microversion_parse.get_version(flask.request.headers,
                                                       mv.SAHARA_SERVICE_TYPE)
    if requested_version is None:
        requested_version = mv.MIN_API_VERSION
    elif requested_version == mv.LATEST:
        requested_version = mv.MAX_API_VERSION
    return requested_version
 def test_legacy_headers_prefer(self):
     headers = {
         'header-one': 'alpha',
         'openstack-compute-api-version': '3.7',
         'x-openstack-nova-api-version': ' 2.1, 9.2 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['openstack-compute-api-version',
                         'x-openstack-nova-api-version'])
     self.assertEqual('3.7', version)
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['x-openstack-nova-api-version',
                         'openstack-compute-api-version'])
     self.assertEqual('9.2', version)
 def test_capitalized_headers(self):
     headers = {
         'X-Openstack-Ironic-Api-Version': '123.456'
     }
     version = microversion_parse.get_version(
         headers, service_type='ironic',
         legacy_headers=['X-Openstack-Ironic-Api-Version'])
     self.assertEqual('123.456', version)
예제 #10
0
def get_requested_microversion():
    requested_version = microversion_parse.get_version(
        flask.request.headers, api_version.RESERVATION_SERVICE_TYPE)
    if requested_version is None:
        requested_version = api_version.MIN_API_VERSION
    elif requested_version == api_version.LATEST:
        requested_version = api_version.MAX_API_VERSION

    return requested_version
 def test_unfolded_service(self):
     headers = [
         ('header-one', 'alpha'),
         ('openstack-api-version', 'compute 1.0'),
         ('openstack-api-version', 'compute 2.0'),
         ('openstack-api-version', '3.0'),
     ]
     version = microversion_parse.get_version(
         headers, service_type='compute')
     self.assertEqual('2.0', version)
 def test_unfolded_service(self):
     headers = [
         ('header-one', 'alpha'),
         ('openstack-api-version', 'compute 1.0'),
         ('openstack-api-version', 'compute 2.0'),
         ('openstack-api-version', '3.0'),
     ]
     version = microversion_parse.get_version(headers,
                                              service_type='compute')
     self.assertEqual('2.0', version)
예제 #13
0
파일: api.py 프로젝트: openstack/sahara
def get_requested_microversion():
    requested_version = microversion_parse.get_version(
        flask.request.headers,
        mv.SAHARA_SERVICE_TYPE
    )
    if requested_version is None:
        requested_version = mv.MIN_API_VERSION
    elif requested_version == mv.LATEST:
        requested_version = mv.MAX_API_VERSION
    return requested_version
예제 #14
0
 def test_get_version_from_environ(self):
     environ = {
         'PATH_INFO': '/foo/bar',
         'HTTP_OPENSTACK_API_VERSION': 'placement 2.1',
         'HTTP_CONTENT_TYPE': 'application/json'
     }
     expected_version = '2.1'
     headers = microversion_parse.headers_from_wsgi_environ(environ)
     version = microversion_parse.get_version(headers, 'placement')
     self.assertEqual(expected_version, version)
 def test_get_version_from_environ_legacy(self):
     environ = {'PATH_INFO': '/foo/bar',
                'HTTP_X_OPENSTACK_PLACEMENT_API_VERSION': '2.1',
                'HTTP_CONTENT_TYPE': 'application/json'}
     expected_version = '2.1'
     headers = microversion_parse.headers_from_wsgi_environ(environ)
     version = microversion_parse.get_version(
         headers, 'placement',
         legacy_headers=['x-openstack-placement-api-version'])
     self.assertEqual(expected_version, version)
 def test_legacy_headers_straight(self):
     headers = {
         'header-one': 'alpha',
         'openstack-compute-api-version': ' 2.1 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['openstack-CoMpUte-api-version'])
     self.assertEqual('2.1', version)
 def test_legacy_headers_folded(self):
     headers = wb_headers.EnvironHeaders({
         'HTTP_HEADER_ONE': 'alpha',
         'HTTP_X_OPENSTACK_NOVA_API_VERSION': ' 2.1, 9.2 ',
         'HTTP_HEADER_TWO': 'beta',
     })
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['x-openstack-nova-api-version'])
     self.assertEqual('9.2', version)
 def test_unfolded_in_name(self):
     headers = [
         ('header-one', 'alpha'),
         ('x-openstack-nova-api-version', '1.0'),
         ('x-openstack-nova-api-version', '2.0'),
         ('openstack-telemetry-api-version', '3.0'),
     ]
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['x-openstack-nova-api-version'])
     self.assertEqual('2.0', version)
 def test_legacy_headers_folded(self):
     headers = {
         'header-one': 'alpha',
         'openstack-compute-api-version': ' 2.1, 9.2 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers,
         service_type='compute',
         legacy_headers=['openstack-compute-api-version'])
     self.assertEqual('9.2', version)
 def test_older_legacy_headers(self):
     headers = {
         'header-one': 'alpha',
         'x-openstack-nova-api-version': ' 2.1, 9.2 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers, service_type='compute',
         legacy_headers=['openstack-nova-api-version',
                         'x-openstack-nova-api-version'])
     # We don't do x- for service types.
     self.assertEqual('9.2', version)
 def test_unfolded_in_name(self):
     headers = [
         ('header-one', 'alpha'),
         ('x-openstack-nova-api-version', '1.0'),
         ('x-openstack-nova-api-version', '2.0'),
         ('openstack-telemetry-api-version', '3.0'),
     ]
     version = microversion_parse.get_version(
         headers,
         service_type='compute',
         legacy_headers=['x-openstack-nova-api-version'])
     self.assertEqual('2.0', version)
예제 #22
0
 def test_get_version_from_environ_legacy(self):
     environ = {
         'PATH_INFO': '/foo/bar',
         'HTTP_X_OPENSTACK_PLACEMENT_API_VERSION': '2.1',
         'HTTP_CONTENT_TYPE': 'application/json'
     }
     expected_version = '2.1'
     headers = microversion_parse.headers_from_wsgi_environ(environ)
     version = microversion_parse.get_version(
         headers,
         'placement',
         legacy_headers=['x-openstack-placement-api-version'])
     self.assertEqual(expected_version, version)
 def test_older_legacy_headers(self):
     headers = {
         'header-one': 'alpha',
         'x-openstack-nova-api-version': ' 2.1, 9.2 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers,
         service_type='compute',
         legacy_headers=[
             'openstack-nova-api-version', 'x-openstack-nova-api-version'
         ])
     # We don't do x- for service types.
     self.assertEqual('9.2', version)
 def test_preference(self):
     headers = {
         'header-one': 'alpha',
         'openstack-api-version': 'compute 11.12, telemetry 9.7',
         'openstack-compute-api-version': '3.7',
         'x-openstack-nova-api-version': ' 2.1, 9.2 ',
         'header-two': 'beta',
     }
     version = microversion_parse.get_version(
         headers,
         service_type='compute',
         legacy_headers=[
             'openstack-compute-api-version', 'x-openstack-nova-api-version'
         ])
     self.assertEqual('11.12', version)
예제 #25
0
파일: version.py 프로젝트: jaypipes/enamel
def extract_version(headers):
    """Extract the microversion from Version.HEADER

    There may be multiple headers and some which don't match our
    service.
    """
    found_version = microversion_parse.get_version(headers, service_type=SERVICE_TYPE)

    version_string = found_version or min_version_string()
    request_version = parse_version_string(version_string)
    # We need a version that is in VERSION and within MIX and MAX.
    # This gives us the option to administratively disable a
    # version if we really need to.
    if str(request_version) in VERSIONS and request_version.matches():
        return request_version
    raise ValueError("Unacceptable version header: %s" % version_string)
예제 #26
0
def extract_version(headers):
    """Extract the microversion from Version.HEADER

    There may be multiple headers and some which don't match our
    service.
    """
    found_version = microversion_parse.get_version(headers,
                                                   service_type=SERVICE_TYPE)

    version_string = found_version or min_version_string()
    request_version = parse_version_string(version_string)
    # We need a version that is in VERSION and within MIX and MAX.
    # This gives us the option to administratively disable a
    # version if we really need to.
    if (str(request_version) in VERSIONS and request_version.matches()):
        return request_version
    raise ValueError('Unacceptable version header: %s' % version_string)
예제 #27
0
    def parse_headers(headers, default_version, latest_version):
        """Determine the API version requested based on the headers supplied.

        :param headers: webob headers
        :param default_version: version to use if not specified in headers
        :param latest_version: version to use if latest is requested
        :returns: a tuple of (major, minor) version numbers
        :raises: webob.HTTPNotAcceptable

        """
        version_str = microversion_parse.get_version(
            headers, service_type='infra-optim')

        minimal_version = (1, 0)

        if version_str is None:
            # If requested header is wrong, Watcher answers with the minimal
            # supported version.
            return minimal_version

        if version_str.lower() == 'latest':
            parse_str = latest_version
        else:
            parse_str = version_str

        try:
            version = tuple(int(i) for i in parse_str.split('.'))
        except ValueError:
            version = minimal_version

        # NOTE (alexchadin): Old python-watcherclient sends requests with
        # value of version header is "1". It should be transformed to 1.0 as
        # it was supposed to be.
        if len(version) == 1 and version[0] == 1:
            version = minimal_version

        if len(version) != 2:
            raise exc.HTTPNotAcceptable("Invalid value for %s header" %
                                        Version.string)
        return version
예제 #28
0
    def process_request(self, req):
        """Process api request:
        1. Define if this is request for available versions or not
        2. If it is not version request check extract version
        3. Validate available version and add version info to request
        """
        args = {'method': req.method, 'path': req.path, 'accept': req.accept}
        LOG.debug("Determining version of request: %(method)s %(path)s "
                  "Accept: %(accept)s", args)

        # determine if this is request for versions
        if req.path_info in ('/versions', '/'):
            is_multi = req.path_info == '/'
            return artifacts_versions.Controller.index(
                req, is_multi=is_multi)

        # determine api version from request
        req_version = get_version_from_accept(req.accept, self.vnd_mime_type)
        if req_version is None:
            # determine api version for v0.1 from url
            if req.path_info_peek() == 'v0.1':
                req_version = 'v0.1'
            else:
                # determine api version from microversion header
                LOG.debug("Determine version from microversion header.")
                req_version = microversion_parse.get_version(
                    req.headers, service_type=self.SERVICE_TYPE)

        # validate versions and add version info to request
        if req_version == 'v0.1':
            req.environ['api.version'] = 0.1
        else:
            # validate microversions header
            req.api_version_request = self._get_api_version_request(
                req_version)
            req_version = req.api_version_request.get_string()

        LOG.debug("Matched version: %s", req_version)
        LOG.debug('new path %s', req.path_info)
예제 #29
0
    def check_version_request(self, req):
        """Set API version request based on the request header."""
        api_version = microversion_parse.get_version(req.headers,
                                                     service_type='clustering')
        if api_version is None:
            api_version = wsgi.DEFAULT_API_VERSION
        elif api_version.lower() == 'latest':
            req.version_request = os_ver.max_api_version()
            return

        try:
            ver = vr.APIVersionRequest(api_version)
        except exception.InvalidAPIVersionString as e:
            raise webob.exc.HTTPBadRequest(six.text_type(e))

        if not ver.matches(os_ver.min_api_version(), os_ver.max_api_version()):
            raise exception.InvalidGlobalAPIVersion(
                req_ver=api_version,
                min_ver=six.text_type(os_ver.min_api_version()),
                max_ver=six.text_type(os_ver.max_api_version()))

        req.version_request = ver
예제 #30
0
    def process_request(self, req):
        """Process api request:
        1. Define if this is request for available versions or not
        2. If it is not version request check extract version
        3. Validate available version and add version info to request
        """
        args = {'method': req.method, 'path': req.path, 'accept': req.accept}
        LOG.debug(
            "Determining version of request: %(method)s %(path)s "
            "Accept: %(accept)s", args)

        # determine if this is request for versions
        if req.path_info in ('/versions', '/'):
            is_multi = req.path_info == '/'
            return artifacts_versions.Controller.index(req, is_multi=is_multi)

        # determine api version from request
        req_version = get_version_from_accept(req.accept, self.vnd_mime_type)
        if req_version is None:
            # determine api version for v0.1 from url
            if req.path_info_peek() == 'v0.1':
                req_version = 'v0.1'
            else:
                # determine api version from microversion header
                LOG.debug("Determine version from microversion header.")
                req_version = microversion_parse.get_version(
                    req.headers, service_type=self.SERVICE_TYPE)

        # validate versions and add version info to request
        if req_version == 'v0.1':
            req.environ['api.version'] = 0.1
        else:
            # validate microversions header
            req.api_version_request = self._get_api_version_request(
                req_version)
            req_version = req.api_version_request.get_string()

        LOG.debug("Matched version: %s", req_version)
        LOG.debug('new path %s', req.path_info)
 def test_no_headers(self):
     headers = {}
     version = microversion_parse.get_version(headers,
                                              service_type='compute')
     self.assertEqual(None, version)
 def test_no_headers(self):
     headers = {}
     version = microversion_parse.get_version(
         headers, service_type='compute')
     self.assertEqual(None, version)