public synchronized ServerImpl getServer(String addr) { if (server == null) { checkProperties(); ClassLoaderHolder loader = null; try { if (bus != null) { ClassLoader newLoader = bus.getExtension(ClassLoader.class); if (newLoader != null) { loader = ClassLoaderUtils.setThreadContextClassloader(newLoader); } } // Initialize the endpointName so we can do configureObject QName origEpn = endpointName; if (endpointName == null) { JaxWsImplementorInfo implInfo = new JaxWsImplementorInfo(getImplementorClass()); endpointName = implInfo.getEndpointName(); } if (serviceFactory != null) { serverFactory.setServiceFactory(serviceFactory); } /*if (serviceName != null) { serverFactory.getServiceFactory().setServiceName(serviceName); }*/ configureObject(this); endpointName = origEpn; // Set up the server factory serverFactory.setAddress(addr); serverFactory.setStart(false); serverFactory.setEndpointName(endpointName); serverFactory.setServiceBean(implementor); serverFactory.setBus(bus); serverFactory.setFeatures(getFeatures()); serverFactory.setInvoker(invoker); serverFactory.setSchemaLocations(schemaLocations); if (serverFactory.getProperties() != null) { serverFactory.getProperties().putAll(properties); } else { serverFactory.setProperties(properties); } // Be careful not to override any serverfactory settings as a user might // have supplied their own. if (getWsdlLocation() != null) { serverFactory.setWsdlURL(getWsdlLocation()); } if (bindingUri != null) { serverFactory.setBindingId(bindingUri); } if (serviceName != null) { serverFactory.getServiceFactory().setServiceName(serviceName); } if (implementorClass != null) { serverFactory.setServiceClass(implementorClass); } if (executor != null) { serverFactory.getServiceFactory().setExecutor(executor); } if (handlers.size() > 0) { serverFactory.addHandlers(handlers); } configureObject(serverFactory); server = serverFactory.create(); org.apache.cxf.endpoint.Endpoint endpoint = getEndpoint(); if (in != null) { endpoint.getInInterceptors().addAll(in); } if (out != null) { endpoint.getOutInterceptors().addAll(out); } if (inFault != null) { endpoint.getInFaultInterceptors().addAll(inFault); } if (outFault != null) { endpoint.getOutFaultInterceptors().addAll(outFault); } if (properties != null) { endpoint.putAll(properties); } configureObject(endpoint.getService()); configureObject(endpoint); this.service = endpoint.getService(); if (getWsdlLocation() == null) { // hold onto the wsdl location so cache won't clear till we go away setWsdlLocation(serverFactory.getWsdlURL()); } if (serviceName == null) { setServiceName(serverFactory.getServiceFactory().getServiceQName()); } if (endpointName == null) { endpointName = endpoint.getEndpointInfo().getName(); } } finally { if (loader != null) { loader.reset(); } } } return (ServerImpl) server; }
public static void doHacks() { if (skipHack("org.apache.cxf.JDKBugHacks.all")) { return; } try { // Use the system classloader as the victim for all this // ClassLoader pinning we're about to do. ClassLoaderHolder orig = ClassLoaderUtils.setThreadContextClassloader(ClassLoader.getSystemClassLoader()); try { try { // Trigger a call to sun.awt.AppContext.getAppContext() if (!skipHack("org.apache.cxf.JDKBugHacks.imageIO")) { ImageIO.getCacheDirectory(); } } catch (Throwable t) { // ignore } try { // DocumentBuilderFactory seems to SOMETIMES pin the classloader if (!skipHack("org.apache.cxf.JDKBugHacks.documentBuilderFactory")) { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.newDocumentBuilder(); } } catch (Throwable e) { // ignore } // Several components end up calling: // sun.misc.GC.requestLatency(long) // // Those libraries / components known to trigger memory leaks due to // eventual calls to requestLatency(long) are: // - javax.management.remote.rmi.RMIConnectorServer.start() try { if (!skipHack("org.apache.cxf.JDKBugHacks.gcRequestLatency")) { Class<?> clazz = Class.forName("sun.misc.GC"); Method method = clazz.getDeclaredMethod("currentLatencyTarget"); Long l = (Long) method.invoke(null); if (l != null && l.longValue() == 0) { // something already set it, move on method = clazz.getDeclaredMethod("requestLatency", new Class[] {Long.TYPE}); method.invoke(null, Long.valueOf(36000000)); } } } catch (Throwable e) { // ignore } // Calling getPolicy retains a static reference to the context // class loader. try { // Policy.getPolicy(); if (!skipHack("org.apache.cxf.JDKBugHacks.policy")) { Class<?> policyClass = Class.forName("javax.security.auth.Policy"); Method method = policyClass.getMethod("getPolicy"); method.invoke(null); } } catch (Throwable e) { // ignore } try { // Initializing javax.security.auth.login.Configuration retains a static reference // to the context class loader. if (!skipHack("org.apache.cxf.JDKBugHacks.authConfiguration")) { Class.forName( "javax.security.auth.login.Configuration", true, ClassLoader.getSystemClassLoader()); } } catch (Throwable e) { // Ignore } // Creating a MessageDigest during web application startup // initializes the Java Cryptography Architecture. Under certain // conditions this starts a Token poller thread with TCCL equal // to the web application class loader. if (!skipHack("org.apache.cxf.JDKBugHacks.securityProviders")) { java.security.Security.getProviders(); } try { // Several components end up opening JarURLConnections without first // disabling caching. This effectively locks the file. // JAXB does this and thus affects us pretty badly. // Doesn't matter that this JAR doesn't exist - just as long as // the URL is well-formed if (!skipHack("org.apache.cxf.JDKBugHacks.defaultUsesCaches")) { URL url = new URL("jar:file://dummy.jar!/"); URLConnection uConn = new URLConnection(url) { @Override public void connect() throws IOException { // NOOP } }; uConn.setDefaultUseCaches(false); } } catch (Throwable e) { // ignore } } finally { if (orig != null) { orig.reset(); } } } catch (Throwable t) { // ignore } }
/** * Performs the publication action by setting up a {@link Server} instance based on this * endpoint's configuration. * * @param addr the optional endpoint address. * @throws IllegalStateException if the endpoint cannot be published/republished * @throws SecurityException if permission checking is enabled and policy forbids publishing * @throws WebServiceException if there is an error publishing the endpoint * @see #checkPublishPermission() * @see #checkPublishable() * @see #getServer(String) */ protected void doPublish(String addr) { checkPublishPermission(); checkPublishable(); ServerImpl serv = null; ClassLoaderHolder loader = null; try { if (bus != null) { ClassLoader newLoader = bus.getExtension(ClassLoader.class); if (newLoader != null) { loader = ClassLoaderUtils.setThreadContextClassloader(newLoader); } } serv = getServer(addr); if (addr != null) { EndpointInfo endpointInfo = serv.getEndpoint().getEndpointInfo(); if (!endpointInfo.getAddress().contains(addr)) { endpointInfo.setAddress(addr); } if (publishedEndpointUrl != null) { endpointInfo.setProperty(WSDLGetUtils.PUBLISHED_ENDPOINT_URL, publishedEndpointUrl); } if (publishedEndpointUrl != null && wsdlLocation != null) { // early update the publishedEndpointUrl so that endpoints in the same app sharing the // same wsdl // do not require all of them to be queried for wsdl before the wsdl is finally fully // updated Definition def = endpointInfo .getService() .getProperty(WSDLServiceBuilder.WSDL_DEFINITION, Definition.class); if (def == null) { def = bus.getExtension(WSDLManager.class).getDefinition(wsdlLocation); } new WSDLGetUtils().updateWSDLPublishedEndpointAddress(def, endpointInfo); } if (null != properties) { for (Entry<String, Object> entry : properties.entrySet()) { endpointInfo.setProperty(entry.getKey(), entry.getValue()); } } this.address = endpointInfo.getAddress(); } serv.start(); publishable = false; } catch (Exception ex) { try { stop(); } catch (Exception e) { // Nothing we can do. } throw new WebServiceException(ex); } finally { if (loader != null) { loader.reset(); } } }
private Object doChainedInvocation( URI uri, MultivaluedMap<String, String> headers, OperationResourceInfo ori, Object body, int bodyIndex, Exchange exchange, Map<String, Object> invocationContext) throws Throwable { Bus configuredBus = getConfiguration().getBus(); Bus origBus = BusFactory.getAndSetThreadDefaultBus(configuredBus); ClassLoaderHolder origLoader = null; try { ClassLoader loader = configuredBus.getExtension(ClassLoader.class); if (loader != null) { origLoader = ClassLoaderUtils.setThreadContextClassloader(loader); } Message outMessage = createMessage(body, ori.getHttpMethod(), headers, uri, exchange, invocationContext, true); if (bodyIndex != -1) { outMessage.put(Type.class, ori.getMethodToInvoke().getGenericParameterTypes()[bodyIndex]); } outMessage.getExchange().setOneWay(ori.isOneway()); setSupportOnewayResponseProperty(outMessage); outMessage.setContent(OperationResourceInfo.class, ori); setPlainOperationNameProperty(outMessage, ori.getMethodToInvoke().getName()); outMessage.getExchange().put(Method.class, ori.getMethodToInvoke()); outMessage.put( Annotation.class.getName(), getMethodAnnotations(ori.getAnnotatedMethod(), bodyIndex)); if (body != null) { outMessage.put("BODY_INDEX", bodyIndex); } outMessage.getInterceptorChain().add(bodyWriter); Map<String, Object> reqContext = getRequestContext(outMessage); reqContext.put(OperationResourceInfo.class.getName(), ori); reqContext.put("BODY_INDEX", bodyIndex); // execute chain doRunInterceptorChain(outMessage); Object[] results = preProcessResult(outMessage); if (results != null && results.length == 1) { return results[0]; } try { return handleResponse(outMessage, ori.getClassResourceInfo().getServiceClass()); } finally { completeExchange(outMessage.getExchange(), true); } } finally { if (origLoader != null) { origLoader.reset(); } if (origBus != configuredBus) { BusFactory.setThreadDefaultBus(origBus); } } }