Retrieve the quartz exception handler bean.
@param context
@return
552455
public QuartzExceptionHandler getQuartzExceptionHandler(final JobExecutionContext context) {
        QuartzExceptionHandler exceptionHandler = null;
        try {
            final ApplicationContext applicationContext = getApplicationContext(context);

            exceptionHandler = (QuartzExceptionHandler) applicationContext.getBean(QUARTZ_EXCEPTION_HANDLER_BEAN_NAME);

        } catch (JobExecutionException e) {
        	logger.error("An error occurs getting the Quartz exception Handler", e);
        }

        return exceptionHandler;
    }
984336
@SuppressWarnings("rawtypes")
  public Class getException() {
    try {
      return Class.forName(errorParam, true, Thread.currentThread().getContextClassLoader()).newInstance().getClass();
    } catch (Exception e) {
      return null;
    }
  }
576873
@Override
  public final HandlerEntityRequest<RS>
    lazyGetHandlerEntityRequest() throws Exception {
    String beanName = this.factoryAppBeans.getHandlerEntityRequestName();
    @SuppressWarnings("unchecked")
    HandlerEntityRequest<RS> hndlEntityReq = (HandlerEntityRequest<RS>)
      this.factoryAppBeans.getBeansMap().get(beanName);
    if (hndlEntityReq == null) {
      hndlEntityReq = new HandlerEntityRequest<RS>();
      hndlEntityReq.setWriteTi(this.factoryAppBeans.getWriteTi());
      hndlEntityReq.setReadTi(this.factoryAppBeans.getReadTi());
      hndlEntityReq.setWriteReTi(this.factoryAppBeans.getWriteReTi());
      hndlEntityReq.setWrReSpTr(this.factoryAppBeans.getWrReSpTr());
      hndlEntityReq
        .setSrvDatabase(this.factoryAppBeans.lazyGetSrvDatabase());
      hndlEntityReq.setFillEntityFromReq(
        this.factoryAppBeans.lazyGetFillEntityFromReq());
      hndlEntityReq.setLogger(
        this.factoryAppBeans.lazyGetLogger());
      hndlEntityReq.setSecureLogger(
        this.factoryAppBeans.lazyGetSecureLogger());
      hndlEntityReq
        .setEntitiesFactoriesFatory(lazyGetFctBcFctSimpleEntities());
      hndlEntityReq
        .setProcessorsFactory(lazyGetFctBnProcessors());
      hndlEntityReq
        .setProcessorsNamesHolder(new HldProcessorNames());
      hndlEntityReq
        .setEntitiesProcessorsFactory(lazyGetFctBnEntitiesProcessors());
      hndlEntityReq
        .setEntitiesProcessorsNamesHolder(new HldEntitiesProcessorNames());
      @SuppressWarnings("unchecked")
      HashMap<String, Class<?>> mcl = (HashMap<String, Class<?>>)
        this.factoryAppBeans.getEntitiesMap().clone();
      hndlEntityReq.setEntitiesMap(mcl);
      lazyGetFctBnProcessors().getSrvEntitiesPage()
        .setEntitiesMap(mcl);
      this.factoryAppBeans.getBeansMap().put(beanName, hndlEntityReq);
      this.factoryAppBeans.lazyGetLogger().info(null, AFactoryAppBeans.class,
        beanName + " has been created.");
    }
    return hndlEntityReq;
  }
1289197
public URLStreamHandler getHandler() throws Exception {
        String handlerString = getSSLProtocolPackageHandler() + ".https.Handler";
        URLStreamHandler streamHandler = null;

        try {
            ClassLoader cl = AccessController.doPrivileged(getCtxClassLoader);
            if (cl != null) {
                streamHandler = (URLStreamHandler) cl.loadClass(handlerString).newInstance();
            } else {
                streamHandler = (URLStreamHandler) Class.forName(handlerString).newInstance();
            }
            return streamHandler;
        } catch (Exception e) {
            FFDCFilter.processException(e, getClass().getName(), "getHandler", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "Exception loading https stream handler.", new Object[] { e });
            Tr.error(tc, "ssl.load.https.stream.handler.CWPKI0025E", new Object[] { handlerString, e.getMessage() });
            throw e;
        }
    }
426088
public Resolution intercept(ExecutionContext context) throws Exception {
        // Continue on and execute other filters and the lifecycle code.
        Resolution resolution = context.proceed();
        
        // Get all fields with session.
        Collection<Field> fields = getSessionFields(context.getActionBean().getClass());
        
        // Restores values from session.
        if (LifecycleStage.ActionBeanResolution.equals(context.getLifecycleStage())) {
            this.restoreFields(fields, context.getActionBean(), context.getActionBeanContext());
        }
        // Store values in session.
        if (LifecycleStage.EventHandling.equals(context.getLifecycleStage())) {
            // Dont't update values in session if a validation error occured.
            if (context.getActionBeanContext().getValidationErrors().isEmpty()) {
            	if (fields.size() > 0)
            		this.saveFields(fields, context.getActionBean(), context.getActionBeanContext().getRequest().getSession());
            }
        }
        
        return resolution;
    }
611470
protected AjaxExceptionHandler findHandlerComponent(FacesContext context, Throwable rootCause) {
        AjaxExceptionHandlerVisitCallback visitCallback = new AjaxExceptionHandlerVisitCallback(rootCause);

        context.getViewRoot().visitTree(VisitContext.createVisitContext(context), visitCallback);

        Map<String, AjaxExceptionHandler> handlers = visitCallback.getHandlers();

        // get handler by exception type
        AjaxExceptionHandler handler = handlers.get(rootCause.getClass().getName());

        // lookup by inheritance hierarchy
        if (handler == null) {
            Class throwableClass = rootCause.getClass();
            while (handler == null && throwableClass.getSuperclass() != Object.class) {
                throwableClass = throwableClass.getSuperclass();
                handler = handlers.get(throwableClass.getName());
            }
        }

        // get default handler
        if (handler == null) {
            handler = handlers.get(null);
        }

        return handler;
    }
758831
@AroundInvoke
	public Object intercept(InvocationContext context) throws Exception { // NOPMD
		// cette méthode est appelée par le conteneur ejb grâce à l'annotation AroundInvoke
		if (DISABLED || !EJB_COUNTER.isDisplayed()) {
			return context.proceed();
		}
		// nom identifiant la requête
		final String requestName = getRequestName(context);

		boolean systemError = false;
		try {
			EJB_COUNTER.bindContextIncludingCpu(requestName);
			return context.proceed();
		} catch (final Error e) {
			// on catche Error pour avoir les erreurs systèmes
			// mais pas Exception qui sont fonctionnelles en général
			systemError = true;
			throw e;
		} finally {
			// on enregistre la requête dans les statistiques
			EJB_COUNTER.addRequestForCurrentContext(systemError);
		}
	}
962584
@Override
  public Trigger getTrigger(String triggerKey) throws SchedulerException {

    validateState();

    return quartzSchedulerResources.getJobStore().retrieveTrigger(triggerKey);
  }
848272
protected void configureHandlerInterceptor(ApplicationContext context) {
        if (context.containsBean(HANDLER_INTERCEPTOR_BEAN_NAME)) {
            DelegatingHandlerInterceptor handlerInterceptor = context.getBean(HANDLER_INTERCEPTOR_BEAN_NAME, DelegatingHandlerInterceptor.class);
            handlerInterceptor.setInterceptors(adaptInterceptors(httpServer.getInterceptors(), context));
        }
    }
279645
protected function _enableExceptionHandler(KDispatcherContextInterface $context)
    {
        $handler = $this->getObject('exception.handler');

        if (!$handler->isEnabled(KExceptionHandlerInterface::TYPE_EXCEPTION))
        {
            $handler->enable(KExceptionHandlerInterface::TYPE_EXCEPTION);
            $this->addCommandCallback('after.send', '_revertExceptionHandler');
        }
    }
67345
protected function getHandlersForContext($context = null)
    {
        $handlers = $this->config()->get('token_handlers');
        if (empty($handlers)) {
            throw new Exception('No token handlers were registered');
        }

        // If we've been given a context, limit to that context + global handlers.
        // Otherwise only allow global handlers (i.e. exclude named ones)
        $allowedContexts = ['*'];
        if ($context) {
            $allowedContexts[] = $context;
        }

        // Filter handlers by context
        $handlers = array_filter($handlers, function ($handler) use ($allowedContexts) {
            return in_array($handler['context'], $allowedContexts);
        });

        // Sort handlers by priority
        uasort($handlers, function ($a, $b) {
            if (!array_key_exists('priority', $a) || !array_key_exists('priority', $b)) {
                return 0;
            }

            return ($a['priority'] < $b['priority']) ? -1 : 1;
        });

        return $handlers;
    }
750992
public static synchronized TypefaceCache getInstance(Context context) {
		if (sInstance == null)
			sInstance = new TypefaceCache((Application)context.getApplicationContext());
		return sInstance;
	}
743442
@Override
    public ExceptionListener getExceptionListener() throws JMSRuntimeException {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getExceptionListener");

        ExceptionListener exceptionListener = null;

        try {
            exceptionListener = jmsConnection.getExceptionListener();
        } catch (JMSException jmse) {
            throw (JMSRuntimeException) JmsErrorUtils.getJMS2Exception(jmse, JMSRuntimeException.class);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "getExceptionListener", new Object[] { exceptionListener });
        }

        return exceptionListener;
    }
1009985
@Override
    public Object get() throws InterruptedException, ExecutionException {
        ScheduledFuture<?> curr;
        synchronized (this.triggerContextMonitor) {
            curr = this.currentFuture;
        }
        return curr.get();
    }
1016565
public ServletContextHandler getHandler() {
    ServletContextHandler contextHandler = new ServletContextHandler();
    contextHandler.setContextPath(SERVLET_PATH);
    contextHandler.addServlet(new ServletHolder(new MetricsServlet(mCollectorRegistry)), "/");
    return contextHandler;
  }
346058
public void alarm(Object context)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.entry(this, tc, "alarm", context);
    
    btmLockManager.lock();
    boolean btmLocked = true;
    timeoutLockManager.lockExclusive();
    boolean timeoutLocked = true;
    try
    {
      //we won't be called unless there are alarms which have timedout but check anyway
      if (!timedout.isEmpty() && !isStopped)
      {
        btmLockManager.unlock();
        btmLocked = false;
        //see defect 280069:
        //So that we can release the exclusive lock before calling processTimedoutEntries
        //(and so avoid deadlock on streamStatus monitor) we take a local copy 
        //(which therefore cannot be modified by anyone behind us) and create 
        //a new list; this replaces holding the exclusive lock for the duration of the method
        //and then clearing the list at the end. 
        
        List tempTimeoutList = timedout; //take a local copy of the list
        
        timedout = new ArrayList<BatchedTimeoutEntry>(); //the timeout entries will be dealt with
        //presently. Meantime we empty the timedout list so that subsequent timeouts
        //can be added to it without affecting processTimedoutEntries
        
        timeoutLockManager.unlockExclusive(); //we no longer care if timedout
        timeoutLocked = false;
        //changes underneath us so we can release the exclusive lock.

        try
        {
          //call the processor with the list of timedout BTEs, which should not be changed
          handler.processTimedoutEntries(tempTimeoutList);
          
          // We had a good batch - clear any previous failures
          batchFailed = false;
          batchCleared = false;
        }
        catch(Throwable e)
        {
          // FFDC the problem with the alarm, but don't re-throw the exception
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
            "1:280:1.24",
            new Object[] {this, handler, tempTimeoutList});
          
          SibTr.exception(tc, e);          
          
          // Alarms registered with the BatchedTimeoutManager are set to auto-repeat,
          // if we simply report the failure in an alarm it'll probably happen again
          // and again, forever. So we need to take steps to stop that happening, by
          // removing entries and possibly even stopping the manager (athough as a manager
          // is specific to a certain object (e.g. a specific AOStream) the damage should 
          // be contained - although still serious.
          
          // We worked the previous time so we'll give the alarms one more try before
          // bombing out
          if(!batchFailed)
            batchFailed = true;
         // If we've failed before, this was our last chance, something is wrong with
          // at least one of the entries, but we can't tell which one so we'll have to
          // remove all the entries - which will stop the error happening over and over
          // again (but not fix the reason for the error!)
          else
          {
            batchFailed = false;
            
            // Remove all the entries and see if that stops the error happening
            Iterator itr = tempTimeoutList.iterator();
            while(itr.hasNext())
            {
              BatchedTimeoutEntry bte = (BatchedTimeoutEntry)itr.next();
              removeTimeoutEntry(bte);
            }

            // If we've already been here and cleared the entries but something has
            // reregistered a new alarm that caused another problem (probably the same
            // one) we just give up and stop the alarm manager to prevent new alarms
            // being registered
            if(batchCleared)
            {
              // This is serious, throw another FFDC
              SIErrorException e2 =
                new SIErrorException(
                  nls.getFormattedMessage(
                    "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                    new Object[] {
                      "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                      "1:325:1.24" },
                    null), e);
              
              FFDCFilter.processException(
                e2,
                "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                "1:331:1.24",
                this);
              
              SibTr.exception(tc, e2);
              
              // Stop the timer
              stopTimer();
            }
            // Remember that we've just cleared up after a problem
            else
              batchCleared = true;
          }
        }
        //restart the entries
        restartEntries(tempTimeoutList);      
      }
    }
    finally
    {
      if(timeoutLocked)
        timeoutLockManager.unlockExclusive();
      if(btmLocked)
        btmLockManager.unlock();
    }
        
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.exit(tc, "alarm");
  }
831963
public static Throwable getConfigException()
  {
    ClassLoader loader = Thread.currentThread().getContextClassLoader();

    for (; loader != null; loader = loader.getParent()) {
      if (loader instanceof EnvironmentClassLoader) {
        EnvironmentClassLoader envLoader = (EnvironmentClassLoader) loader;

        if (envLoader.getConfigException() != null)
          return envLoader.getConfigException();
      }
    }

    return null;
  }