If the TracingEndpointCaller class is in a classpath - use it, otherwise use BasicEndpointCaller.

@param properties properties argument for endpoint caller
@return endpoint caller instance
175090
public static EndpointCaller initializeEndpointCaller(Properties properties) {
        EndpointCaller ec;
        try {
            LOG.debug("Initializing endpoint caller. Checking whether '{}' is in classpath.",
                    TRACING_ENDPOINT_CALLER_CLASSNAME);
            Class<?> tracingEndpointCallerClass = Class.forName(TRACING_ENDPOINT_CALLER_CLASSNAME);
            Constructor<?> tracingEndpointCallerConstructor = tracingEndpointCallerClass
                    .getConstructor(Properties.class);
            ec = (EndpointCaller) tracingEndpointCallerConstructor.newInstance(properties);
            LOG.debug("Using '{}' instance as endpoint caller object.", TRACING_ENDPOINT_CALLER_CLASSNAME);
        } catch (Exception e) {
            ec = new BasicEndpointCaller(properties);
            LOG.debug("Using '{}' instance as endpoint caller object.", BasicEndpointCaller.class.getName());
        }
        return ec;
    }
1152388
public boolean invokeEndpoint(final MessageEndpoint endpoint,
            final SIBusMessage message, final AbstractConsumerSession session,
            final SITransaction transaction, String debugMEName)
            throws ResourceAdapterInternalException {

        final String methodName = "invokeEndpoint";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, new Object[] { endpoint,
                    message, session, transaction });
        }

        // Check that endpoint is a MessageListener
        if (!(endpoint instanceof MessageListener)) {

            throw new ResourceAdapterInternalException(NLS.getFormattedMessage(
                    ("UNEXPECTED_ENDPOINT_CWSJR1482"), new Object[] { endpoint,
                            MessageListener.class }, null));

        }

        final MessageListener listener = (MessageListener) endpoint;

        boolean success;
        try {

            // Convert to JMS message - no session to pass in, but do pass in 'pass thru' props
            final Message jmsMessage = _jmsUtils.inboundMessagePath(message,
                    null, passThruProps);
            
            // This is a debug property and only set if the value is not null (it will be null unless a
            // runtime system property is set.
            if ((debugMEName != null) && (!debugMEName.equals ("")))
            {
            	if (message instanceof JsJmsMessage)
            	{
            		((JsJmsMessage) message).setObjectProperty ("MEName", debugMEName);
            	}
            	else 
            	{
                    if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) 
                    {
                    	SibTr.debug(TRACE, "Can not set MDB location in message as the message is not a JsJmsMessage - its a " + jmsMessage.getClass().getName());
                    }
            	}
            }
            
            // Deliver message
            listener.onMessage(jmsMessage);
            success = true;

        } catch (final Throwable exc) {

            // Failed to deliver message
            FFDCFilter.processException(exc, CLASS_NAME + "." + methodName,
                    FFDC_PROBE_1, this);
            if (TRACE.isEventEnabled()) {
                SibTr.exception(this, TRACE, exc);
            }
            success = false;

        }

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

    }
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;
    }
1251172
@SuppressWarnings("unchecked")
	@Override
	public T getEndpoint(String nodeID) {
		Endpoint[] array;
		if (nodeID == null && preferLocal) {
			array = getEndpointsByNodeID(this.nodeID);
			if (array.length == 0) {
				array = endpoints;
			}
		} else {
			array = getEndpointsByNodeID(nodeID);
		}
		if (array.length == 0) {
			return null;
		}
		if (array.length == 1) {
			return (T) array[0];
		}
		return (T) next(array);
	}
657499
public KafkaEndpointBuilder producerProperties(Map<String, Object> producerProperties) {
        endpoint.getEndpointConfiguration().setProducerProperties(producerProperties);
        return this;
    }
423198
@Override
    public void registerEndpoint(QName serviceName, String endpointURL,
            org.talend.schemas.esb.locator._2011._11.BindingType binding,
            org.talend.schemas.esb.locator._2011._11.TransportType transport,
            SLPropertiesType properties) throws ServiceLocatorFault,
            InterruptedExceptionFault {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Registering endpoint " + endpointURL + " for service "
                    + serviceName + "...");
        }
        try {
            initLocator();
            BindingType bindingType = binding == null ? BindingType.SOAP11
                    : BindingType.valueOf(binding.value());
            TransportType transportType = transport == null ? TransportType.HTTP
                    : TransportType.valueOf(transport.value());
            SLPropertiesImpl slProps = null;
            if (properties != null) {
                slProps = new SLPropertiesImpl();
                List<EntryType> entries = properties.getEntry();
                for (EntryType entry : entries) {
                    slProps.addProperty(entry.getKey(), entry.getValue());
                }
            }
            SimpleEndpoint eprProvider = new SimpleEndpoint(serviceName,
                    endpointURL, bindingType, transportType, slProps);

            locatorClient.register(eprProvider, true);
        } catch (ServiceLocatorException e) {
            ServiceLocatorFaultDetail serviceFaultDetail = new ServiceLocatorFaultDetail();
            serviceFaultDetail.setLocatorFaultDetail(serviceName.toString()
                    + "throws ServiceLocatorFault");
            throw new ServiceLocatorFault(e.getMessage(), serviceFaultDetail);
        } catch (InterruptedException e) {
            InterruptionFaultDetail interruptionFaultDetail = new InterruptionFaultDetail();
            interruptionFaultDetail.setInterruptionDetail(serviceName
                    .toString() + "throws InterruptionFault");
            throw new InterruptedExceptionFault(e.getMessage(),
                    interruptionFaultDetail);
        }
    }
519399
private static TraceServiceGrpc.TraceServiceStub getTraceServiceStub(
      String endPoint, Boolean useInsecure, SslContext sslContext) {
    ManagedChannelBuilder<?> channelBuilder;
    if (useInsecure) {
      channelBuilder = ManagedChannelBuilder.forTarget(endPoint).usePlaintext();
    } else {
      channelBuilder =
          NettyChannelBuilder.forTarget(endPoint)
              .negotiationType(NegotiationType.TLS)
              .sslContext(sslContext);
    }
    ManagedChannel channel = channelBuilder.build();
    return TraceServiceGrpc.newStub(channel);
  }
1108773
public Map<String,Object> addPropertiesFile(Map<String,Object> properties)
    {
        String propertiesPath = (String)properties.get("webStartPropertiesFile");
        if (propertiesPath == null)
            return properties;
        if (propertiesPath.startsWith("/"))
            propertiesPath = propertiesPath.substring(1);
        URL url = null;
        try {
            url = ClassServiceUtility.getClassService().getResourceURL(propertiesPath, null, null, this.getClass().getClassLoader());
        } catch (RuntimeException e) {
            e.printStackTrace();    // ???
        }           
        Reader inStream = null;
        if (url != null)
        {
            try {
                inStream = new InputStreamReader(url.openStream());
            } catch (Exception e) {
                // Not found
            }
        }
        if (inStream != null)
        {
            try {
                // Todo may want to add cache info (using bundle lastModified).
                Properties cachedProperties = new Properties();
                cachedProperties.load(inStream);
                inStream.close();
                for (Object key : cachedProperties.keySet())
                {
                    properties.put(key.toString(), cachedProperties.get(key));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return properties;
    }
525919
private static Endpoint initServiceEndpoint(EndpointRegistry epRegistry, String contextPath, String servletName)
   {
      if (contextPath.startsWith("/"))
         contextPath = contextPath.substring(1);

      final ObjectName oname = ObjectNameFactory.create(Endpoint.SEPID_DOMAIN + ":" + Endpoint.SEPID_PROPERTY_CONTEXT
            + "=" + contextPath + "," + Endpoint.SEPID_PROPERTY_ENDPOINT + "=" + servletName);
      Endpoint endpoint = epRegistry.getEndpoint(oname);
      if (endpoint == null)
      {
         throw Messages.MESSAGES.cannotObtainEndpoint(oname);
      }

      //Inject the EJB and JNDI resources if possible
      injectServiceAndHandlerResources(endpoint);

      return endpoint;
   }
766992
@Override
  public void setEndpointAddress(BindingProvider soapClient, String endpointAddress) {
    soapClient.getRequestContext().put(
        BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointAddress);
  }
759370
@Override
    public SibRaEndpointInvoker getEndpointInvoker()
                    throws ResourceAdapterInternalException {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
            SibTr.entry(this, TRACE, "getEndpointInvoker");

        // Create a Map of properties to pass into the new endpoint invoker. These are admin props that are
        // relevant in other classes so need to be passed through... NOTE: 'forwarder does not modify...'
        // is synonymous with 'producer does not modify...', so translate the forwarder property here to make
        // payload handling for incoming messages simpler
        Map<String, String> passThruProps = new HashMap<String, String>();
        passThruProps.put(JmsraConstants.CONSUMER_DOES_NOT_MODIFY_PAYLOAD_AFTER_GET, getConsumerDoesNotModifyPayloadAfterGet());
        passThruProps.put(JmsraConstants.PRODUCER_DOES_NOT_MODIFY_PAYLOAD_AFTER_SET, getForwarderDoesNotModifyPayloadAfterSet());

        // Create a new endpoint invoker, passing in the pass thru props
        JmsJcaEndpointInvokerImpl epInvoker = new JmsJcaEndpointInvokerImpl(passThruProps);

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
            SibTr.exit(this, TRACE, "getEndpointInvoker", epInvoker);

        return epInvoker;
    }
1007218
protected void configureEndpointInfoProperties(EndpointInfo libertyEndpointInfo, org.apache.cxf.service.model.EndpointInfo cxfEndpointInfo) {

        //Disable jaxb validation event handler, as IBM FastPath does not support this, which will finally fallback to RI unmarshall
        cxfEndpointInfo.setProperty(SET_JAXB_VALIDATION_EVENT_HANDLER, false);

//        //Set autoRewriteSoapAddressForAllServices with true by default, which will override all the services in the target WSDL file
//        cxfEndpointInfo.setProperty(WSDLGetUtils.AUTO_REWRITE_ADDRESS_ALL, true);

        //Set WSDL_DESCRIPTION property
//        try {
//            String wsdlLocation = libertyEndpointInfo.getWsdlLocation();
//            if (wsdlLocation != null && !(wsdlLocation.isEmpty())) {
//                URI wsdlDescription = new URI(wsdlLocation);
//                cxfEndpointInfo.setProperty("URI", wsdlDescription);
//            }
//        } catch (URISyntaxException e) {
//            //donothing
//        }
        Map<String, String> endpointProperties = libertyEndpointInfo.getEndpointProperties();
        if (endpointProperties != null && !endpointProperties.isEmpty()) {
            for (Entry<String, String> entry : endpointProperties.entrySet()) {
                cxfEndpointInfo.setProperty(entry.getKey(), entry.getValue());
            }
        }
    }
15738
@Nonnull
  public FineUploader5Session setEndpoint (@Nullable final ISimpleURL aEndpoint)
  {
    ValueEnforcer.notNull (aEndpoint, "Endpoint");
    m_aSessionEndpoint = aEndpoint;
    return this;
  }
640266
public static String traceOutput(Map<String, Object> properties) {
    SortedSet<String> propertyNames = new TreeSet<>(properties.keySet());
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    Iterator<String> propertyNameIterator = propertyNames.iterator();
    while (propertyNameIterator.hasNext()) {
      String propertyName = propertyNameIterator.next();
      sb.append(propertyName).append(": ");
      appendValue(sb, properties.get(propertyName));
      if (propertyNameIterator.hasNext()) {
        sb.append(", ");
      }
    }
    sb.append("}");
    return sb.toString();
  }
131898
@Pure
	<CT extends RoadConnection> CT getEndPoint(Class<CT> connectionClass) {
		final StandardRoadConnection connection = this.lastConnection;
		if (connection == null) {
			return null;
		}
		if (connectionClass.isAssignableFrom(StandardRoadConnection.class)) {
			return connectionClass.cast(connection);
		}
		if (connectionClass.isAssignableFrom(RoadConnectionWithArrivalSegment.class)) {
			return connectionClass.cast(new RoadConnectionWithArrivalSegment(connection, this, false));
		}
		throw new IllegalArgumentException("unsupported RoadConnection class");  //$NON-NLS-1$
	}
1280493
private W3CEndpointReference buildEndpoint(QName serviceName, String adress) {
        W3CEndpointReferenceBuilder builder = new W3CEndpointReferenceBuilder();
        // builder.serviceName(serviceName);
        builder.address(adress);
        SLEndpoint endpoint = null;
        try {
            endpoint = locatorClient.getEndpoint(serviceName, adress);
        } catch (ServiceLocatorException e) {
            throw new WebApplicationException(Response
                    .status(Status.INTERNAL_SERVER_ERROR)
                    .entity(e.getMessage()).build());
        } catch (InterruptedException e) {
            throw new WebApplicationException(Response
                    .status(Status.INTERNAL_SERVER_ERROR)
                    .entity(e.getMessage()).build());
        }
        if (endpoint != null) {
            SLProperties properties = endpoint.getProperties();
            if (properties != null && !properties.getPropertyNames().isEmpty()) {
                EndpointTransformerImpl transformer = new EndpointTransformerImpl();

                DOMResult result = new DOMResult();
                transformer.writePropertiesTo(properties, result);
                Document docResult = (Document) result.getNode();

                builder.metadata(docResult.getDocumentElement());
            }
        }
        return builder.build();
    }
668568
public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;

        if (bugsnag != null) {
            bugsnag.setEndpoints(endpoint, null);
        }
    }