<pre>
Uses API Endpoints to handle requests.
</pre>

<code>.google.appengine.v1.ApiEndpointHandler api_endpoint = 4;</code>
194867
public com.google.appengine.v1.ApiEndpointHandlerOrBuilder getApiEndpointOrBuilder() {
    if (handlerTypeCase_ == 4) {
       return (com.google.appengine.v1.ApiEndpointHandler) handlerType_;
    }
    return com.google.appengine.v1.ApiEndpointHandler.getDefaultInstance();
  }
593822
def get(cls, api=None, **kwargs):
        
        api = api if api else cls._API
        extra = {
            'resource': cls.__name__,
            'query': {}
        }
        logger.info('Getting resources', extra=extra)
        endpoints = api.get(url=cls._URL['get']).json()
        return Endpoints(api=api, **endpoints)
431336
public Method getEndpointMethod() throws ResourceAdapterInternalException {

        final String methodName = "getEndpointMethod";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        if (ON_MESSAGE_METHOD == null) {

            try {

                ON_MESSAGE_METHOD = SibRaMessageListener.class.getMethod(
                        "onMessage", new Class[] { SIBusMessage.class,
                                AbstractConsumerSession.class,
                                SITransaction.class });

            } catch (final Exception exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_2);
                if (TRACE.isEntryEnabled()) {
                    SibTr.exception(TRACE, exception);
                }
                throw new ResourceAdapterInternalException(NLS
                        .getFormattedMessage("ON_MESSAGE_CWSIV0851",
                                new Object[] { exception }, null), exception);

            }

        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, ON_MESSAGE_METHOD);
        }
        return ON_MESSAGE_METHOD;

    }
647787
def post(self, endpoint, **kwargs):
        
        return self._request(requests.post, endpoint, **kwargs)
1150073
public Method getEndpointMethod() throws ResourceAdapterInternalException {

        final String methodName = "getEndpointMethod";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        if (ON_MESSAGE_METHOD == null) {

            try {

                ON_MESSAGE_METHOD = MessageListener.class.getMethod(
                        "onMessage", new Class[] { Message.class });

            } catch (final Exception exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_2, this);
                if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
                    SibTr.exception(this, TRACE, exception);
                }
                throw new ResourceAdapterInternalException(NLS
                        .getFormattedMessage("ON_MESSAGE_CWSJR1483",
                                new Object[] { exception }, null), exception);

            }

        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, ON_MESSAGE_METHOD);
        }
        return ON_MESSAGE_METHOD;

    }
668568
public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;

        if (bugsnag != null) {
            bugsnag.setEndpoints(endpoint, null);
        }
    }
93023
public void returnInvocationHandler(MessageEndpointBase endpoint, boolean reuse)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "MEF.returnInvocationHandler");

        // Use pool only if one was created.
        if (ivInvocationHandlerPool != null) // d423445.1
        {
            if (reuse)
            {
                MessageEndpointBase.reset(endpoint); // F73236 PooledObject removed, call reset() directly
                ivInvocationHandlerPool.put(endpoint);
            }

            //f743-7046 start
            // Notify any thread, but only 1 thread since release
            // only occurred on one MessageEndpoint, that is blocked
            // in createEndpoint method waiting for a release method
            // to be called on some MessageEndpoint proxy.
            synchronized (ivStateLock)
            {
                // d643869
                // According to the JCA 1.5 spec section 12.5 the proxy
                // instance can be pooled and reused by the same resource adapter.
                // The proxy instance is not freed here and the count is
                // not decremented.  The discard method handles freeing
                // proxy instances that are pooled and decrementing the count.
                // --ivNumberOfMessageEndpointsCreated;
                ivStateLock.notify();
            }
            //f743-7046 end
        }

        // d643869
        // Decrement the ivNumberOfMessageEndpointsCreated and null the proxy
        // because the MessageEndpointHandler was not returned to the pool
        // and will be garbage collected by the JVM
        if (ivInvocationHandlerPool == null || !reuse)
        {
            synchronized (ivStateLock)
            {
                --ivNumberOfMessageEndpointsCreated;
                //endpointBase.ivProxy = null;
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "MEF.returnInvocationHandler"); // d643869

    }
1053910
public String get(String endpoint, String params) throws IOException {
        return this.get(endpoint, params, null);
    }
1340401
public ApiResponse<GetOutboundResponse> getOutboundSettingsWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getOutboundSettingsValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<GetOutboundResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
277085
public AuthenticationRequestBuilder getAuthorizationEndPoint() {
    for(Authentication auth : authentications.values()) {
     if (auth instanceof OAuth) {
        OAuth oauth = (OAuth) auth;
        return oauth.getAuthenticationRequestBuilder();
      }
    }
    return null;
  }
817814
function Endpoint(url) {
  if (!(this instanceof Endpoint)) return new Endpoint(url);

  var p;
  if (typeof url === 'string') {
    //parse url
    var rr = REGEXP_URL.exec(url);
    if (rr) {
      p = {
        protocol: rr[1],
        username: rr[2],
        password: rr[3],
        host: rr[4],
        port: rr[5],
        path: rr[6],
        url: rr[0]
      };
    }
  } else if (typeof url === 'object') {
    p = url;
  }
  p || (p = {});

  this.protocol = (p.protocol && p.protocol.toLowerCase()) || PROTOCOL.TCP;
  p.username && (this.username = p.username);
  p.password && (this.password = p.password);
  this.host = p.host || 'localhost';
  this.port = p.port || defaultPort(this.protocol);
  p.path && (this.path = p.path);
  p.url && (this.url = p.url);
}
1340578
public ApiResponse<ApiEndpointsSuccess> getApiEndpointsWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getApiEndpointsValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<ApiEndpointsSuccess>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
1258106
function (endPoint, request, response) {
                var self = this,
                    context,
                    requestHandler,
                    handledWithErrorHandler = false,
                    buffers = [],
                    bufferLength = 0;

                // create a new application domain for the request
                var domain = Domain.create();

                domain.add(request);
                domain.add(response);

                // request.setEncoding('utf8');

                request.on('data', function (chunk) {
                    buffers.push(chunk);
                    bufferLength += chunk.length;
                });

                response.on('close', function () {
                    domain.dispose();
                });

                domain.on('error', handleError);


                request.on('end', function () {

                    request.body = new Buffer(bufferLength);

                    var pos = 0;

                    for (var i = 0; i < buffers.length; i++) {
                        buffers[i].copy(request.body, pos);
                        pos += buffers[i].length;
                    }

                    request.body.content = request.body.toString();

                    buffers = null;

                    domain.run(function () {
                        // create the new context object
                        context = new Context(self, endPoint, request, response);

                        // and set the chosen handler
                        requestHandler = self.$handlers.getRequestHandler(context);
                        context.handler = requestHandler;

                        flow()
                            .seq(function (cb) {
                                context._executeHook("beginRequest", cb);
                            })
                            .seq(function (cb) {
                                if (requestHandler.$.autoStartSession) {
                                    context.session.start(cb);
                                } else {
                                    cb();
                                }
                            })
                            .seq(function (cb) {
                                requestHandler.handleRequest(context, cb);
                            })
                            .exec(function (err) {
                                if (err) {
                                    handleError(err);
                                } else {
                                    context.response.end();
                                }
                            });
                    });
                });

                function handleError(err) {

                    if (!handledWithErrorHandler) {
                        handledWithErrorHandler = true;

                        var exceptionHandler = new ExceptionHandler(err);
                        try {
                            exceptionHandler.handleRequest(context, function (err) {
                                err && handleErrorTheHardWay(err);
                            });
                        } catch (e) {
                            handleErrorTheHardWay(err);
                        }

                    } else {
                        // error handler didn't do the job well
                        handleErrorTheHardWay(err);
                    }
                }

                function handleErrorTheHardWay(error) {

                    console.error(error);

                    try {
                        response.writeHead(500);
                    } catch (error) {
                        console.error('Error sending 500', error, request.url);
                    }

                    response.end('Internal Server Error');
                    domain.dispose();
                }

            }
26899
def handleFlaskGetRequest(id_, flaskRequest, endpoint):
    
    if flaskRequest.method == "GET":
        return handleHttpGet(id_, endpoint)
    else:
        raise exceptions.MethodNotAllowedException()
632738
public Object getValue(String parameter, Endpoint endpoint){
        return endpoint.getEndpointConfiguration().getParameter(parameter);
        
    }
126134
List<Endpoint> endpoints() {
        try {
            String urlString = String.format("%s/api/v1/namespaces/%s/pods", kubernetesMaster, namespace);
            return enrichWithPublicAddresses(parsePodsList(callGet(urlString)));
        } catch (RestClientException e) {
            return handleKnownException(e);
        }
    }
959205
public static String ENDPOINT_WRONG_PARAMS(Object arg0, Object arg1) {
        return localizer.localize(localizableENDPOINT_WRONG_PARAMS(arg0, arg1));
    }