Publish JAX-WS server side endpoint. Returns javax.xml.ws.Endpoint to enable further customization.
356150
public Endpoint publishEndpoint(EndpointBuilder endpointBuilder) {
        checkArgument(endpointBuilder != null, "EndpointBuilder is null");

        EndpointImpl cxfendpoint = new EndpointImpl(bus, endpointBuilder.getService());
        if(endpointBuilder.publishedEndpointUrl() != null) {
            cxfendpoint.setPublishedEndpointUrl(endpointBuilder.publishedEndpointUrl());
        }
        else if(publishedEndpointUrlPrefix != null) {
            cxfendpoint.setPublishedEndpointUrl(publishedEndpointUrlPrefix + endpointBuilder.getPath());
        }
        cxfendpoint.publish(endpointBuilder.getPath());

        // MTOM support
        if (endpointBuilder.isMtomEnabled()) {
            ((SOAPBinding)cxfendpoint.getBinding()).setMTOMEnabled(true);
        }

        Invoker invoker = cxfendpoint.getService().getInvoker();

        // validating invoker
        ValidatorFactory vf = Validation.buildDefaultValidatorFactory();
        invoker = this.createValidatingInvoker(invoker, vf.getValidator());

        if (endpointBuilder.getSessionFactory() != null) {
            // Add invoker to handle UnitOfWork annotations. Note that this invoker is set up before
            // instrumented invoker(s) in order for instrumented invoker(s) to wrap "unit of work" invoker.
            invoker = unitOfWorkInvokerBuilder.create(
                    endpointBuilder.getService(), invoker, endpointBuilder.getSessionFactory());
            cxfendpoint.getService().setInvoker(invoker);
        }

        // Replace CXF service invoker with instrumented invoker(s)
        invoker = instrumentedInvokerBuilder.create(endpointBuilder.getService(), invoker);
        cxfendpoint.getService().setInvoker(invoker);

        if (endpointBuilder.getAuthentication() != null) {
            // Configure CXF in interceptor to handle basic authentication
            BasicAuthenticationInterceptor basicAuthInterceptor = this.createBasicAuthenticationInterceptor();
            basicAuthInterceptor.setAuthenticator(endpointBuilder.getAuthentication());
            cxfendpoint.getInInterceptors().add(basicAuthInterceptor);
        }

        // CXF interceptors

        if (endpointBuilder.getCxfInInterceptors() != null) {
            cxfendpoint.getInInterceptors().addAll(endpointBuilder.getCxfInInterceptors());
        }

        if (endpointBuilder.getCxfInFaultInterceptors() != null) {
            cxfendpoint.getInFaultInterceptors().addAll(endpointBuilder.getCxfInFaultInterceptors());
        }

        if (endpointBuilder.getCxfOutInterceptors() != null) {
            cxfendpoint.getOutInterceptors().addAll(endpointBuilder.getCxfOutInterceptors());
        }

        if (endpointBuilder.getCxfOutFaultInterceptors() != null) {
            cxfendpoint.getOutFaultInterceptors().addAll(endpointBuilder.getCxfOutFaultInterceptors());
        }

        if (endpointBuilder.getProperties() != null) {
            cxfendpoint.getProperties().putAll(
                    endpointBuilder.getProperties());
        }

        return cxfendpoint;
    }
428915
def _get_service_endpoint(context, svc, region=None, public=True):
    
    region = _safe_region(region)
    # If a specific context is passed, use that. Otherwise, use the global
    # identity reference.
    context = context or identity
    url_type = {True: "public", False: "private"}[public]
    svc_obj = context.services.get(svc)
    if not svc_obj:
        return None
    ep = svc_obj.endpoints.get(region, {}).get(url_type)
    if not ep:
        # Try the "ALL" region, and substitute the actual region
        ep = svc_obj.endpoints.get("ALL", {}).get(url_type)
    return ep
302439
public EndpointInfo build(EndpointInfoBuilderContext ctx, String serviceImplBeanClassName, EndpointType endpointType) throws UnableToAdaptException {

        EndpointInfo endpointInfo = new EndpointInfo(serviceImplBeanClassName, endpointType);
        endpointInfo.setBeanName((String) ctx.getContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_BEAN_NAME));
        endpointInfo.setServletName((String) ctx.getContextEnv(JaxWsConstants.ENV_ATTRIBUTE_ENDPOINT_SERVLET_NAME));

        invokeConfigurators(ctx, ConfigMethod.PREPARE, endpointInfo);
        invokeConfigurators(ctx, ConfigMethod.CONFIG, endpointInfo);

        validate(ctx, endpointInfo);

        ctx.clearContextEnv();

        return endpointInfo;
    }
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));
}
535478
public String getEndpoint() {
        String url = this.endpoint;
        // if the set endpoint does not contain a protocol, append protocol to head of it
        if (this.endpoint != null && this.endpoint.length() > 0
                && endpoint.indexOf("://") < 0) {
            url = protocol.toString().toLowerCase() + "://" + endpoint;
        }
        return url;
    }
1085588
def to_string(self, endpoints):
        # type: (List[EndpointDescription]) -> str
        
        # Make the ElementTree
        root = self._make_xml(endpoints)
        tree = ElementTree.ElementTree(root)

        # Force the default name space
        ElementTree.register_namespace("", EDEF_NAMESPACE)

        # Make the XML
        # Prepare a StringIO output
        output = StringIO()

        # Try to write with a correct encoding
        tree.write(
            output,
            encoding=self._encoding,
            xml_declaration=self._xml_declaration,
        )

        return output.getvalue().strip()
1273536
public EndpointType getServiceEndpointFromInterfaceNBinding(DescriptionType descriptionType, String interfaceName, BindingType binding)
    {
        for (Object nextElement : descriptionType.getImportOrIncludeOrTypes())
        {
            Object nextType = null;
            if (nextElement instanceof JAXBElement)
                nextType = ((JAXBElement)nextElement).getValue();
            // Create the service type
            if (nextType instanceof ServiceType)
            {
                QName qname = ((ServiceType)nextType).getInterface();
                if (qname != null)
                    if (interfaceName.equalsIgnoreCase(qname.getLocalPart()))
                {
                    for (Object nextElement2 : ((ServiceType)nextType).getEndpointOrFeatureOrProperty())
                    {
                        Object endpoint = null;
                        if (nextElement2 instanceof JAXBElement)
                            endpoint = ((JAXBElement)nextElement2).getValue();
                        if (endpoint instanceof EndpointType)
                        {
                            EndpointType endpointType = (EndpointType)endpoint;
                            String address = endpointType.getAddress();
                            QName qname2 = endpointType.getBinding();
                            String ns = qname2.getNamespaceURI();
                            String name = qname2.getLocalPart();
                            if (name.equalsIgnoreCase(binding.getName()))
                                return endpointType;
                        }
                    }
                }
            }
        }
        return null;
    }
239451
function ConnectionServer(endpoint, options, connectionListener) {
  events.EventEmitter.call(this);

  if (!(endpoint instanceof Endpoint)) {
    endpoint = new Endpoint(endpoint);
  }
  if (typeof options === 'function') {
    connectionListener = options;
    options = undefined;
  }

  this.endpoint = endpoint;
  this.options = options || {};
  if (typeof connectionListener === 'function') {
    this.on('connection', connectionListener);
  }

  listen.call(this);
}
848565
public EndpointBuilder<T> export(Class<?>... additional) {
		this.additionalInterfaces.addAll(Arrays.asList(additional));
		return this;
	}
43959
@NotNull
    @ObjectiveCName("addEndpoint:")
    public ConfigurationBuilder addEndpoint(@NotNull String url) {
        try {
            endpoints.addEndpoint(url);
        } catch (ConnectionEndpointArray.UnknownSchemeException e) {
            throw new RuntimeException(e.getMessage());
        }
        return this;
    }
1159202
private URI addEndPoint(String endPoint) throws URISyntaxException {

        if (StringUtils.isEmpty(endPoint) || endPoint.equals("/")) {
            return this.baseUri;
        }

        if (this.baseUri.getPath().endsWith("/") || endPoint.startsWith("/")) {
            endPoint = this.baseUri.getPath() + endPoint;
        } else {
            endPoint = this.baseUri.getPath() + "/" + endPoint;
        }

        URI uri = null;

        URIBuilder builder = new URIBuilder();

        builder.setScheme(this.baseUri.getScheme());
        builder.setHost(this.baseUri.getHost());
        builder.setPort(this.baseUri.getPort());
        builder.setPath(endPoint);

        uri = builder.build();
        return uri;
    }
1327177
public ResourceName withEndpoint(String endpoint) {
    return new ResourceName(template, values, Preconditions.checkNotNull(endpoint));
  }
630187
def create_endpoint(self, endpoint):
        
        self._validate_subscriber_id(endpoint.subscriber_id)

        url = "/notification/v1/endpoint"
        response = NWS_DAO().postURL(
            url, self._write_headers(), self._json_body(endpoint.json_data()))

        if response.status != 201:
            raise DataFailureException(url, response.status, response.data)
        return response.status
543527
function addHttpEndpointNames(spec) {
  for(var i = 0; i < spec.endpoints.length; i++) {
    var endpoint = spec.endpoints[i];
    if (endpoint.response.contentType.contentType.toLowerCase() === 'javascript') {
      endpoint.response.contentType.contentType = 'application/json';
      endpoint.response.contentType.eval = true;
    } else {
      endpoint.response.content = endpoint.response.content.replace(/(\r\n|\n|\r)/gm,"");
    }
    endpoint.httpMethod = endpoint.method.toLowerCase();
  }
  return spec;
}
1202598
protected void customizeWSDLGetInterceptor(Class<?> implBeanClass) {
        String wsdlLocation = endpointInfo.getWsdlLocation();
        URL wsdlUrl = JaxWsUtils.resolve(wsdlLocation, jaxWsModuleMetaData.getModuleContainer());
        boolean wsdlLocationExisted = true;
        boolean wsdlLocationEmpty = StringUtils.isEmpty(wsdlLocation);
        //check whether there is jax-ws-catalog enabled
        if (!wsdlLocationEmpty && wsdlUrl == null)
        {
            wsdlLocationExisted = false;
            OASISCatalogManager catalogManager = jaxWsModuleMetaData.getServerMetaData().getServerBus().getExtension(OASISCatalogManager.class);
            String resolvedLocation = null;
            if (catalogManager != null)
            {

                try {
                    resolvedLocation = catalogManager.resolveSystem(wsdlLocation);

                    if (resolvedLocation == null) {
                        resolvedLocation = catalogManager.resolveURI(wsdlLocation);
                    }
                } catch (MalformedURLException e) {
                    //do nothing
                } catch (IOException e) {
                    //do nothing
                }

            }
            if (resolvedLocation != null)
            {
                wsdlLocationExisted = true;
            }

        }

//        if (!wsdlLocationEmpty && wsdlUrl == null) {
//            wsdlLocationExisted = false;
//        }
        if (!wsdlLocationEmpty && wsdlLocationExisted) {
            return;
        }
        String protocolBinding = endpointInfo.getProtocolBinding();
        if (!JaxWsUtils.isWSDLGenerationSupported(protocolBinding) || !wsdlLocationExisted) {
            List<Interceptor<? extends Message>> inInterceptors = server.getEndpoint().getInInterceptors();
            inInterceptors.remove(WSDLGetInterceptor.INSTANCE);
            inInterceptors.add(new LibertyJaxWsCompatibleWSDLGetInterceptor(implBeanClass.getCanonicalName(), wsdlLocation, wsdlLocationExisted));
        }
    }
1210450
private Retrofit.Builder setEndpoint(Retrofit.Builder retrofitBuilder, String endpoint) {
    if (endpoint != null) {
      return retrofitBuilder.baseUrl(endpoint);
    }
    return retrofitBuilder;
  }
731086
private String determineAnnotatedEndpointPath(Class<?> endpointClass) {
        if (endpointClass.isAnnotationPresent(ServerEndpoint.class)) {
            return endpointClass.getAnnotation(ServerEndpoint.class).value();
        } else {
            throw new IllegalArgumentException(String.format("@ServerEndpoint annotation not found on Websocket-class: '%s'. Either annotate the class or register it as a programmatic endpoint using ServerEndpointConfig.class", endpointClass));
        }
    }