/** Publishes the endpoints declared to the provided WSEndpointDeploymentUnit */ public List<Endpoint> publish(ServiceTarget target, WSEndpointDeploymentUnit unit) throws Exception { List<DeploymentAspect> aspects = DeploymentAspectsProvider.getSortedDeploymentAspects(); ClassLoader origClassLoader = SecurityActions.getContextClassLoader(); Deployment dep = null; try { SecurityActions.setContextClassLoader( ClassLoaderProvider.getDefaultProvider().getServerIntegrationClassLoader()); WSDeploymentBuilder.getInstance().build(unit); dep = unit.getAttachment(WSAttachmentKeys.DEPLOYMENT_KEY); dep.addAttachment(ServiceTarget.class, target); DeploymentAspectManager dam = new DeploymentAspectManagerImpl(); dam.setDeploymentAspects(aspects); dam.deploy(dep); } finally { if (dep != null) { dep.removeAttachment(ServiceTarget.class); } SecurityActions.setContextClassLoader(origClassLoader); } Deployment deployment = unit.getAttachment(WSAttachmentKeys.DEPLOYMENT_KEY); deployment.addAttachment( StandardContext.class, startWebApp(host, unit)); // TODO simplify and use findChild later in destroy()/stopWebApp() return deployment.getService().getEndpoints(); }
public synchronized void start(StartContext context) throws StartException { try { final JMSServerManager jmsServer = new JMSServerManagerImpl( hornetQServer.getValue(), new AS7BindingRegistry(context.getController().getServiceContainer())); try { // FIXME - we also need the TCCL here in case the JMSServerManager starts the HornetQServer final ClassLoader loader = getClass().getClassLoader(); SecurityActions.setContextClassLoader(loader); jmsServer.start(); // FIXME - this check is a work-around for AS7-3658 if (!hornetQServer.getValue().getConfiguration().isBackup()) { hornetQServer .getValue() .getRemotingService() .allowInvmSecurityOverride( new HornetQPrincipal( HornetQDefaultCredentials.getUsername(), HornetQDefaultCredentials.getPassword())); } else { hornetQServer .getValue() .registerActivateCallback( new ActivateCallback() { public void preActivate() {} public void activated() { hornetQServer .getValue() .getRemotingService() .allowInvmSecurityOverride( new HornetQPrincipal( HornetQDefaultCredentials.getUsername(), HornetQDefaultCredentials.getPassword())); } public void deActivate() {} }); } } finally { SecurityActions.setContextClassLoader(null); } this.jmsServer = jmsServer; } catch (Exception e) { throw new StartException(e); } }
/** * Stops the container * * @throws IllegalStateException if the container is not running */ public synchronized void stop() { if (!started) { throw WeldMessages.MESSAGES.notStarted("WeldContainer"); } ClassLoader oldTccl = SecurityActions.getContextClassLoader(); try { SecurityActions.setContextClassLoader(deployment.getModule().getClassLoader()); bootstrap.shutdown(); } finally { SecurityActions.setContextClassLoader(oldTccl); ModuleGroupSingletonProvider.removeClassLoader(deployment.getModule().getClassLoader()); } started = false; }
/** * Invokes this method with the provided arguments applying provided mapper * * @param args object * @param mapper if null no mappings are applied method will be invoked using args directly. in * this case the keys of the map gotta be the parameters names as defined in wsdl/wsconsume * generated classes * @return {@link InvocationResultImpl} * @throws WiseWebServiceException There are 4 known failure conditions - The wsdl (url) could not * be found - The wsdl is password protected - The endpoint (url) could not be found - The * endpoint is password protected * @throws InvocationException invocation issue * @throws IllegalArgumentException illegal argument * @throws MappingException mapping issue */ @SuppressWarnings("unchecked") public InvocationResultImpl invoke(Object args, WiseMapper mapper) throws WiseWebServiceException, InvocationException, IllegalArgumentException, MappingException { if (mapper == null) { return this.invoke((Map<String, Object>) args); } ClassLoader oldLoader = SecurityActions.getContextClassLoader(); Map<String, Object> mappingResults; try { SecurityActions.setContextClassLoader(this.getEndpoint().getClassLoader()); mappingResults = mapper.applyMapping(args); } finally { SecurityActions.setContextClassLoader(oldLoader); } return this.invoke(mappingResults); }
public void afterCompletion(int status) { boolean trace = log.isTraceEnabled(); // This is an independent point of entry. We need to make sure the // thread is associated with the right context class loader ClassLoader oldCl = SecurityActions.getContextClassLoader(); SecurityActions.setContextClassLoader(container.getClassLoader()); container.pushENC(); ctx.hasTxSynchronization(false); ctx.setTransaction(null); try { try { // If rolled back -> invalidate instance if (status != Status.STATUS_ROLLEDBACK) { switch (commitOption) { // Keep instance cached after tx commit case ConfigurationMetaData.A_COMMIT_OPTION: throw new IllegalStateException( "Commit option A not allowed with this Interceptor"); // Keep instance active, but invalidate state case ConfigurationMetaData.B_COMMIT_OPTION: break; // Invalidate everything AND Passivate instance case ConfigurationMetaData.C_COMMIT_OPTION: break; case ConfigurationMetaData.D_COMMIT_OPTION: throw new IllegalStateException( "Commit option D not allowed with this Interceptor"); } } try { if (ctx.getId() != null) container.getPersistenceManager().passivateEntity(ctx); } catch (Exception ignored) { } container.getInstancePool().free(ctx); } finally { if (trace) log.trace("afterCompletion, clear tx for ctx=" + ctx + ", tx=" + tx); } } // synchronized(lock) finally { container.popENC(); SecurityActions.setContextClassLoader(oldCl); } }
/** * Starts the weld container * * @throws IllegalStateException if the container is already running */ public synchronized void start() { if (started) { throw WeldMessages.MESSAGES.alreadyRunning("WeldContainer"); } ModuleGroupSingletonProvider.addClassLoaders( deployment.getModule().getClassLoader(), deployment.getSubDeploymentClassLoaders()); started = true; ClassLoader oldTccl = SecurityActions.getContextClassLoader(); try { SecurityActions.setContextClassLoader(deployment.getModule().getClassLoader()); bootstrap.startContainer(environment, deployment); bootstrap.startInitialization(); bootstrap.deployBeans(); bootstrap.validateBeans(); bootstrap.endInitialization(); } finally { SecurityActions.setContextClassLoader(oldTccl); } }
@Override public void start(final StartContext context) throws StartException { final ClassLoader cl = SecurityActions.getContextClassLoader(); try { SecurityActions.setContextClassLoader(classLoader); final BeanManagerImpl beanManager = this.beanManager.getValue(); for (final Class<?> interceptor : interceptorClasses) { interceptorInjections.put( interceptor, WeldEEInjection.createWeldEEInjection(interceptor, null, beanManager)); } if (ejbName != null) { EjbDescriptor<Object> descriptor = beanManager.getEjbDescriptor(ejbName); bean = beanManager.getBean(descriptor); } injectionTarget = WeldEEInjection.createWeldEEInjection(componentClass, bean, beanManager); } finally { SecurityActions.setContextClassLoader(cl); } }
protected void verifyPassword(VerifyPasswordCallback vpc) throws NamingException { String credential = vpc.getValue(); ClassLoader currentTCCL = SecurityActions.getContextClassLoader(); if (currentTCCL != null) SecurityActions.setContextClassLoader(null); String baseDN = options.get(BASE_CTX_DN); String baseFilter = options.get(BASE_FILTER_OPT); InitialLdapContext ctx = this.constructInitialLdapContext(bindDN, bindCredential); bindDNAuthentication(ctx, userName, credential, baseDN, baseFilter); vpc.setVerified(true); }
@Override public void destroy(Context context) throws Exception { List<Endpoint> eps = context.getEndpoints(); if (eps == null || eps.isEmpty()) { return; } Deployment deployment = eps.get(0).getService().getDeployment(); List<DeploymentAspect> aspects = DeploymentAspectsProvider.getSortedDeploymentAspects(); try { stopWebApp(deployment.getAttachment(StandardContext.class)); } finally { ClassLoader origClassLoader = SecurityActions.getContextClassLoader(); try { SecurityActions.setContextClassLoader( ClassLoaderProvider.getDefaultProvider().getServerIntegrationClassLoader()); DeploymentAspectManager dam = new DeploymentAspectManagerImpl(); dam.setDeploymentAspects(aspects); dam.undeploy(deployment); } finally { SecurityActions.setContextClassLoader(origClassLoader); } } }
public void afterCompletion(int status) { boolean trace = log.isTraceEnabled(); // This is an independent point of entry. We need to make sure the // thread is associated with the right context class loader ClassLoader oldCl = SecurityActions.getContextClassLoader(); boolean setCl = !oldCl.equals(container.getClassLoader()); if (setCl) { SecurityActions.setContextClassLoader(container.getClassLoader()); } container.pushENC(); int commitOption = ctx.isPassivateAfterCommit() ? ConfigurationMetaData.C_COMMIT_OPTION : EntitySynchronizationInterceptor.this.commitOption; lock.sync(); // The context is no longer synchronized on the TX ctx.hasTxSynchronization(false); ctx.setTxAssociation(GlobalTxEntityMap.NONE); ctx.setTransaction(null); try { try { // If rolled back -> invalidate instance if (status == Status.STATUS_ROLLEDBACK) { // remove from the cache container.getInstanceCache().remove(ctx.getCacheKey()); } else { switch (commitOption) { // Keep instance cached after tx commit case ConfigurationMetaData.A_COMMIT_OPTION: case ConfigurationMetaData.D_COMMIT_OPTION: // The state is still valid (only point of access is us) ctx.setValid(true); break; // Keep instance active, but invalidate state case ConfigurationMetaData.B_COMMIT_OPTION: // Invalidate state (there might be other points of entry) ctx.setValid(false); break; // Invalidate everything AND Passivate instance case ConfigurationMetaData.C_COMMIT_OPTION: try { // We weren't removed, passivate // Here we own the lock, so we don't try to passivate // we just passivate if (ctx.getId() != null) { container.getInstanceCache().remove(ctx.getId()); container.getPersistenceManager().passivateEntity(ctx); } // If we get this far, we return to the pool container.getInstancePool().free(ctx); } catch (Exception e) { log.debug("Exception releasing context", e); } break; } } } finally { if (trace) log.trace("afterCompletion, clear tx for ctx=" + ctx + ", tx=" + tx); lock.endTransaction(tx); if (trace) log.trace("afterCompletion, sent notify on TxLock for ctx=" + ctx); } } // synchronized(lock) finally { lock.releaseSync(); container.getLockManager().removeLockRef(lock.getId()); container.popENC(); if (setCl) { SecurityActions.setContextClassLoader(oldCl); } } }
/** * Handle a {@code Callback} * * @param c callback * @throws UnsupportedCallbackException If the callback is not supported by this handler * @throws NamingException */ protected void handleCallBack(Callback c) throws UnsupportedCallbackException, NamingException { if (c instanceof VerifyPasswordCallback) { verifyPassword((VerifyPasswordCallback) c); return; } if (c instanceof PasswordCallback == false) return; PasswordCallback passwdCallback = (PasswordCallback) c; String bindDN = getBindDN(); String bindCredential = getBindCredential(); String tmp = options.get(PASSWORD_ATTRIBUTE_ID); if (tmp != null && tmp.length() > 0) { passwordAttributeID = tmp; } InitialLdapContext ctx; ClassLoader currentTCCL = SecurityActions.getContextClassLoader(); try { if (currentTCCL != null) SecurityActions.setContextClassLoader(null); ctx = this.constructInitialLdapContext(bindDN, bindCredential); } catch (NamingException e) { throw new RuntimeException(e); } String timeLimit = (String) options.get(SEARCH_TIME_LIMIT_OPT); if (timeLimit != null) { try { searchTimeLimit = Integer.parseInt(timeLimit); } catch (NumberFormatException e) { } } if (searchTimeLimit == 0) searchTimeLimit = 10000; String baseDN = options.get(BASE_CTX_DN); String baseFilter = options.get(BASE_FILTER_OPT); SearchControls constraints = new SearchControls(); constraints.setSearchScope(SearchControls.SUBTREE_SCOPE); constraints.setTimeLimit(searchTimeLimit); NamingEnumeration<SearchResult> results = null; Object[] filterArgs = {userName}; try { if (baseDN == null) throw PicketBoxMessages.MESSAGES.invalidNullBaseContextDN(); results = ctx.search(baseDN, baseFilter, filterArgs, constraints); if (results.hasMore() == false) { safeClose(results); throw PicketBoxMessages.MESSAGES.failedToFindBaseContextDN(baseDN); } SearchResult sr = results.next(); String name = sr.getName(); String userDN = null; if (sr.isRelative() == true) userDN = name + "," + baseDN; else throw PicketBoxMessages.MESSAGES.unableToFollowReferralForAuth(name); ; safeClose(results); // Finished Authentication. Lets look for the attributes filterArgs = new Object[] {userName, userDN}; results = ctx.search(userDN, baseFilter, filterArgs, constraints); try { while (results.hasMore()) { sr = results.next(); Attributes attributes = sr.getAttributes(); NamingEnumeration<? extends javax.naming.directory.Attribute> ne = attributes.getAll(); while (ne != null && ne.hasMoreElements()) { javax.naming.directory.Attribute ldapAtt = ne.next(); if (passwordAttributeID.equalsIgnoreCase(ldapAtt.getID())) { Object thePass = ldapAtt.get(); setPasswordCallbackValue(thePass, passwdCallback); } } } } finally { safeClose(results); safeClose(ctx); if (currentTCCL != null) SecurityActions.setContextClassLoader(currentTCCL); } } catch (NamingException ne) { PicketBoxLogger.LOGGER.error(ne); } }