If endpoint is explicitly configured, SDK should not do endpoint discovery in anytime.
@param [object] client Service client object.
@api private
350461
function hasCustomEndpoint(client) {
  //if set endpoint is set for specific client, enable endpoint discovery will raise an error.
  if (client._originalConfig && client._originalConfig.endpoint && client._originalConfig.endpointDiscoveryEnabled === true) {
    throw util.error(new Error(), {
      code: 'ConfigurationException',
      message: 'Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.'
    });
  };
  var svcConfig = AWS.config[client.serviceIdentifier] || {};
  return Boolean(AWS.config.endpoint || svcConfig.endpoint || (client._originalConfig && client._originalConfig.endpoint));
}
1029627
public void processHttpChainWork(boolean enableEndpoint, boolean isPause) {
        if (enableEndpoint) {
            // enable the endpoint if it is currently disabled
            // it's ok if the endpoint is stopped, the config update will occur @ next start
            endpointState.compareAndSet(DISABLED, ENABLED);

            if (httpPort >= 0) {
                httpChain.enable();
            }
            if (httpsPort >= 0 && sslFactoryProvider.getService() != null) {
                httpSecureChain.enable();
            }

            if (!isPause) {
                // Use an update action so they pick up the new settings
                performAction(updateAction);
            } else {
                updateAction.run();
            }
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(this, tc, "endpoint disabled: " + (String) endpointConfig.get("id"));
            }

            // The endpoint has been disabled-- stop it now
            endpointState.set(DISABLED);
            if (!isPause) {
                performAction(stopAction);
            } else {
                stopAction.run();
            }
        }
    }
390164
def stub!
      CiscoMSE::Endpoints::Location.any_instance.stub(:clients).and_return( Stub::Data::Location::CLIENTS )
    end
465696
def delete(options = {})
      options = options.merge(endpoint_arn: @arn)
      resp = @client.delete_endpoint(options)
      resp.data
    end
375338
def endpoint_delete(endpoint_id):
    
    client = get_client()
    res = client.delete_endpoint(endpoint_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
1147940
void configureHome(Reflections reflections) {

        log.info("Checking for a / endpoint..");
        Home home = getEndpoint(Home.class, "/", reflections);
        if (home == null) home = new DefaultApiDocumentation();
        printEndpoint(home, "/");
        this.home = home;
    }
275211
function checkBasicSupport(client, metadata, properties) {
  try {
    const supported = client.issuer.token_endpoint_auth_methods_supported;
    if (!supported.includes(properties.token_endpoint_auth_method)) {
      if (supported.includes('client_secret_post')) {
        properties.token_endpoint_auth_method = 'client_secret_post';
      }
    }
  } catch (err) {}
}
358231
def build_root_node(requester)
      if defined?(self.implementation_root)
        root_endpoint_file = File.join(
          self.implementation_root,
          'root_endpoint.rb'
        )
        if File.file?(root_endpoint_file)
          warn "[DEPRECATION] `root_endpoint.rb` is deprecated. Please use `ABSOLUTE_PATH` in your endpoints."
          # Load it and create our base endpoint
          require(root_endpoint_file)
          # RootEndpoint is the special class name for a root endpoint
          root_node_class = self.implementation_module::RootEndpoint
        else
          # 'root_endpoint.rb' doesn't exist, so create a dummy endpoint
          root_node_class = Saddle::RootEndpoint
        end
      else
        # we don't even have an implementation root, so create a dummy endpoint
        root_node_class = Saddle::RootEndpoint
      end
      root_node_class.new(requester, nil, self)
    end
829804
function EndPoint (local) {
  this.listeners = 0;
  this.dgram = dgram.createSocket('udp4');
  this.dgram.on('message', EndPoint.prototype.receive.bind(this));
  this.dgram.bind(local.port, local.address);
  this.local = this.dgram.address();
  this.packet = new Buffer(2048);
  this.sockets = {};
}
45813
function Client(endpointUrl, sourceId) {
		this.restClient = new restClient.Client();

		this.endpointUrl = endpointUrl;

		if (this.endpointUrl) {
			// Remove the trailing slash if necessary
			if (this.endpointUrl.indexOf('/', this.endpointUrl.length - 1) !== -1) {
				this.endpointUrl = this.endpointUrl.substr(0, this.endpointUrl.length - 2);
			}

			// Add the default version if not present
			// TODO: The client should take care of the version in a better way
			if (this.endpointUrl.indexOf('/v1', this.endpointUrl.length - 3) === -1) {
				this.endpointUrl = this.endpointUrl + '/v1';
			}
		}

		if (sourceId !== undefined) {
			this.sourceId = sourceId;
		}
	}
922681
function Client(key, password, endpoint) {
  if (!(this instanceof Client)) {
    return new Client(key, password, endpoint);
  }

  endpoint = typeof endpoint !== 'undefined' ? endpoint : Client.MODE_SANDBOX;

  var _key = key,
    _password = password,
    _endpoint = endpoint,
    _errors = [],
    _isValid = false;

  var emptyErrors = function () {
    _errors = [];
  };

  var addError = function (errorCode) {
    if (_errors.indexOf(errorCode) < 0) {
      _errors.push(errorCode);
    }
    _isValid = false;
  };

  var validate = function () {
    _isValid = true;
    if (!_key || !_password) {
      addError(ClientError.INVALID_CREDENTIAL);
    } else if (!_endpoint) {
      addError(ClientError.INVALID_ENDPOINT);
    }
    if (_errors.length > 0) {
      _isValid = false;
    }
  };

  Object.defineProperties(this, {

    /**
     * @member {String} module:Rapid/Client~Client#key
     */
    key: {
      get: function () {
        return _key;
      },
      set: function (key) {
        emptyErrors();
        _key        = key;
        Service.key = _key;
        validate();
      }
    },

    /**
     * @member {String} module:Rapid/Client~Client#password
     */
    password: {
      get: function () {
        return _password;
      },
      set: function (password) {
        emptyErrors();
        _password        = password;
        Service.password = _password;
        validate();
      }
    },

    /**
     * @member {String} module:Rapid/Client~Client#endpoint
     */
    endpoint: {
      get: function () {
        return _endpoint;
      },
      set: function (endpoint) {
        emptyErrors();
        if (endpoint) {
          switch (endpoint.toLowerCase()) {
            case Client.MODE_SANDBOX:
              _endpoint = Client.ENDPOINT_SANDBOX;
              break;
            case Client.MODE_PRODUCTION:
              _endpoint = Client.ENDPOINT_PRODUCTION;
              break;
            default:
              _endpoint = endpoint;
          }
        } else {
          _endpoint = endpoint;
        }
        Service.baseUrl = _endpoint;
        validate();
      }
    },

    /**
     * @member {Boolean} module:Rapid/Client~Client#isValid
     */
    isValid: {
      get: function () {
        return _isValid;
      }
    },

    /**
     * @member {Array} module:Rapid/Client~Client#errors
     */
    errors: {
      get: function () {
        return _errors;
      }
    }
  });

  this.setCredential(key, password);
  this.endpoint = endpoint;
}
1034732
function RestClient(url, options) { // XXX what are the options?
  // call super
  Endpoint.call(this)

  /*****************************************************************************
   * @property {string} url -- xxx
   */
  this.url = url
  // setting this.client = this !!! this is so that child endpoint get
  // this.client set properly when calling end
  /*****************************************************************************
   * @property {xxx} client -- xxx
   */
  this.client = this
  /*****************************************************************************
   * @property {object} defaultOptions -- xxx
   */
  this.defaultOptions = options || {}

  // setup authenticator
  if ("authentication" in this.defaultOptions) {
    this._setupAuthentication(this.defaultOptions["authentication"])
  }

  // allow accessing "request" module from this client
  this.request = require("request")
}
1017513
public void register(Client client) {
        Exceptions.checkNotClosed(this.closed.get(), this);
        Preconditions.checkNotNull(client, "client");
        synchronized (this.clients) {
            if (!this.clients.contains(client)) {
                this.clients.add(client);
                client.updateGenerations(this.currentGeneration.get(), this.oldestGeneration.get());
            }
        }

        log.info("{} Registered {}.", TRACE_OBJECT_ID, client);
    }
1151153
private void handleEndpointMatch(OngoingRequest request, RuleMatch<Endpoint> match) {
    final Endpoint endpoint = match.getRule().getTarget();
    final Map<String, String> parsedPathArguments = match.parsedPathArguments();
    final Client requestScopedClient = client.wrapRequest(request.request());
    final RequestContext requestContext =
        RequestContexts.create(request.request(),
                               requestScopedClient,
                               parsedPathArguments,
                               request.arrivalTimeNanos(),
                               request.metadata());

    erf.create(request, requestContext, endpoint)
        .run();
  }
1081161
public static Endpoint determineEndpointForRequest(final RequestAbstractType authnRequest,
                                                       final SamlRegisteredServiceServiceProviderMetadataFacade adaptor,
                                                       final String binding) {
        var endpoint = (Endpoint) null;
        if (authnRequest instanceof LogoutRequest) {
            endpoint = adaptor.getSingleLogoutService(binding);
        } else {
            val endpointReq = getAssertionConsumerServiceFromRequest(authnRequest, binding);
            endpoint = endpointReq == null
                ? adaptor.getAssertionConsumerService(binding)
                : endpointReq;
        }

        if (endpoint == null || StringUtils.isBlank(endpoint.getBinding())) {
            throw new SamlException("Assertion consumer service does not define a binding");
        }
        val location = StringUtils.isBlank(endpoint.getResponseLocation()) ? endpoint.getLocation() : endpoint.getResponseLocation();
        if (StringUtils.isBlank(location)) {
            throw new SamlException("Assertion consumer service does not define a target location");
        }
        return endpoint;
    }
132982
function newSSEClientFactory(endpoint) {
    return function(initDict) {
        initDict = initDict || { };
        // get URI options
        var uriOptions = utils.getURIOptions(initDict);
        utils.removeURIOptions(initDict);
        // create a new URI
        var uri = utils.url(endpoint, uriOptions);
        // get auth options
        var authOptions = utils.getAuthOptions([utils.setup(), this, initDict]);
        // sign the URI (automatically removes the secret param from initDict)
        auth.sign(authOptions.key, authOptions.secret, uri);
        // determine whether to use an eventsource or poll the endpoint
        return new EventSource(uri.toString(), initDict);
    };
}
1052470
def endpoint_response(code, type = nil, description = nil, headers = [])
      responses = settings.swagger_current_endpoint_responses
      check_if_not_duplicate(code, responses, 'Response')
      responses[code] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointResponse.new(
        type,
        description,
        settings.swagger_types.types_names,
        headers,
        settings.swagger_response_headers
      )
    end