示例#1
0
 def get_service_ip(cls,
                    service_name,
                    spec_type="ClusterIP",
                    namespace="default"):
     api = cls.k8s_client.CoreV1Api()
     while True:
         time.sleep(5)
         service = api.read_namespaced_service(service_name, namespace)
         if spec_type == "LoadBalancer":
             if service.status.load_balancer.ingress:
                 return service.status.load_balancer.ingress[0].ip
         elif spec_type == "ClusterIP":
             return service.spec.cluster_ip
         else:
             raise lib_exc.NotImplemented()
示例#2
0
    def get_service_ip(
            cls, service_name, spec_type="ClusterIP", namespace="default"):
        api = cls.k8s_client.CoreV1Api()
        while True:
            time.sleep(5)
            service = api.read_namespaced_service(service_name, namespace)
            if spec_type == "LoadBalancer":
                # In case of a cloud provider not being configured, OpenShift
                # allocates an external IP and overwrites the service
                # status/ingress/IP set by Kuryr-controller.
                # In this case, we should retrieve the external IP from
                # Kuryr's annotation.

                if service.status.load_balancer.ingress:
                    endpoints = api.read_namespaced_endpoints(
                        service_name, namespace)
                    annotations = endpoints.metadata.annotations
                    try:
                        ann_dict = json.loads(
                            annotations[K8S_ANNOTATION_LBAAS_STATE])
                        ann_lb_ip = (
                            ann_dict["versioned_object.data"]
                            ["service_pub_ip_info"]
                            ["versioned_object.data"]
                            ["ip_addr"])
                    except KeyError:
                        LOG.info("Waiting till LB's IP appears in annotation "
                                 "(ingress.ip=%s)",
                                 service.status.load_balancer.ingress[0].ip)
                        continue
                    if ann_lb_ip != service.status.load_balancer.ingress[0].ip:
                        LOG.warning(
                            'Annotated pub_ip(%s) != ingress.ip(%s).',
                            ann_lb_ip,
                            service.status.load_balancer.ingress[0].ip)
                        if not CONF.kuryr_kubernetes.cloud_provider:
                            return ann_lb_ip
                    return service.status.load_balancer.ingress[0].ip
            elif spec_type == "ClusterIP":
                return service.spec.cluster_ip
            else:
                raise lib_exc.NotImplemented()
示例#3
0
 def get_service_ip(cls,
                    service_name,
                    spec_type="ClusterIP",
                    namespace="default"):
     api = cls.k8s_client.CoreV1Api()
     while True:
         time.sleep(5)
         service = api.read_namespaced_service(service_name, namespace)
         if spec_type == "LoadBalancer":
             # NOTE(yboaron): In some cases, OpenShift may overwrite
             # LB's IP stored at service.status, we need to make sure that
             # this function will return the IP that was annotated by
             # Kuryr controller
             if service.status.load_balancer.ingress:
                 endpoints = api.read_namespaced_endpoints(
                     service_name, namespace)
                 annotations = endpoints.metadata.annotations
                 try:
                     ann_dict = json.loads(
                         annotations[K8S_ANNOTATION_LBAAS_STATE])
                     ann_lb_ip = (ann_dict["versioned_object.data"]
                                  ["service_pub_ip_info"]
                                  ["versioned_object.data"]["ip_addr"])
                 except KeyError:
                     LOG.info(
                         "Waiting till LB's IP appears in annotation "
                         "(ingress.ip=%s)",
                         service.status.load_balancer.ingress[0].ip)
                     continue
                 if ann_lb_ip != service.status.load_balancer.ingress[0].ip:
                     LOG.warning('Annotated pub_ip(%s) != ingress.ip(%s).',
                                 ann_lb_ip,
                                 service.status.load_balancer.ingress[0].ip)
                     return ann_lb_ip
                 return service.status.load_balancer.ingress[0].ip
         elif spec_type == "ClusterIP":
             return service.spec.cluster_ip
         else:
             raise lib_exc.NotImplemented()
示例#4
0
    def _error_checker(self, method, url, headers, body, resp, resp_body):

        # NOTE(mtreinish): Check for httplib response from glance_http. The
        # object can't be used here because importing httplib breaks httplib2.
        # If another object from a class not imported were passed here as
        # resp this could possibly fail
        if str(type(resp)) == "<type 'instance'>":
            ctype = resp.getheader('content-type')
        else:
            try:
                ctype = resp['content-type']
            # NOTE(mtreinish): Keystone delete user responses doesn't have a
            # content-type header. (They don't have a body) So just pretend it
            # is set.
            except KeyError:
                ctype = 'application/json'

        # It is not an error response
        if resp.status < 400:
            return

        JSON_ENC = ['application/json', 'application/json; charset=utf-8']
        # NOTE(mtreinish): This is for compatibility with Glance and swift
        # APIs. These are the return content types that Glance api v1
        # (and occasionally swift) are using.
        TXT_ENC = [
            'text/plain', 'text/html', 'text/html; charset=utf-8',
            'text/plain; charset=utf-8'
        ]

        if ctype.lower() in JSON_ENC:
            parse_resp = True
        elif ctype.lower() in TXT_ENC:
            parse_resp = False
        else:
            raise exceptions.UnexpectedContentType(str(resp.status), resp=resp)

        if resp.status == 401:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.Unauthorized(resp_body, resp=resp)

        if resp.status == 403:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.Forbidden(resp_body, resp=resp)

        if resp.status == 404:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.NotFound(resp_body, resp=resp)

        if resp.status == 400:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.BadRequest(resp_body, resp=resp)

        if resp.status == 410:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.Gone(resp_body, resp=resp)

        if resp.status == 409:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.Conflict(resp_body, resp=resp)

        if resp.status == 413:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            if self.is_absolute_limit(resp, resp_body):
                raise exceptions.OverLimit(resp_body, resp=resp)
            else:
                raise exceptions.RateLimitExceeded(resp_body, resp=resp)

        if resp.status == 415:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.InvalidContentType(resp_body, resp=resp)

        if resp.status == 422:
            if parse_resp:
                resp_body = self._parse_resp(resp_body)
            raise exceptions.UnprocessableEntity(resp_body, resp=resp)

        if resp.status in (500, 501):
            message = resp_body
            if parse_resp:
                try:
                    resp_body = self._parse_resp(resp_body)
                except ValueError:
                    # If response body is a non-json string message.
                    # Use resp_body as is and raise InvalidResponseBody
                    # exception.
                    raise exceptions.InvalidHTTPResponseBody(message)
                else:
                    if isinstance(resp_body, dict):
                        # I'm seeing both computeFault
                        # and cloudServersFault come back.
                        # Will file a bug to fix, but leave as is for now.
                        if 'cloudServersFault' in resp_body:
                            message = resp_body['cloudServersFault']['message']
                        elif 'computeFault' in resp_body:
                            message = resp_body['computeFault']['message']
                        elif 'error' in resp_body:
                            message = resp_body['error']['message']
                        elif 'message' in resp_body:
                            message = resp_body['message']
                    else:
                        message = resp_body

            if resp.status == 501:
                raise exceptions.NotImplemented(resp_body,
                                                resp=resp,
                                                message=message)
            else:
                raise exceptions.ServerFault(resp_body,
                                             resp=resp,
                                             message=message)

        if resp.status >= 400:
            raise exceptions.UnexpectedResponseCode(str(resp.status),
                                                    resp=resp)