Example #1
0
  private Object findByPrimaryKey(
      final Method callMethod,
      final Object[] args,
      final ThreadContext callContext,
      final InterfaceType interfaceType)
      throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();

    final TransactionPolicy txPolicy =
        createTransactionPolicy(
            beanContext.getTransactionType(callMethod, interfaceType), callContext);

    try {
      final EntityBean bean = (EntityBean) cmpEngine.loadBean(callContext, args[0]);
      if (bean == null) {
        throw new ObjectNotFoundException(beanContext.getDeploymentID() + " : " + args[0]);
      }

      // rebuild the primary key
      final KeyGenerator kg = beanContext.getKeyGenerator();
      final Object primaryKey = kg.getPrimaryKey(bean);

      // create a new ProxyInfo based on the deployment info and primary key
      return new ProxyInfo(beanContext, primaryKey);
    } catch (final FinderException fe) {
      handleApplicationException(txPolicy, fe, false);
    } catch (final Throwable e) { // handle reflection exception
      handleSystemException(txPolicy, e, callContext);
    } finally {
      afterInvoke(txPolicy, callContext);
    }
    throw new AssertionError("Should not get here");
  }
    public void timedOut(Instance instance) {
      BeanContext beanContext = instance.beanContext;

      ThreadContext threadContext =
          new ThreadContext(beanContext, instance.primaryKey, Operation.PRE_DESTROY);
      threadContext.setCurrentAllowedStates(null);
      ThreadContext oldContext = ThreadContext.enter(threadContext);
      try {
        Method remove =
            instance.bean instanceof SessionBean ? SessionBean.class.getMethod("ejbRemove") : null;

        List<InterceptorData> callbackInterceptors = beanContext.getCallbackInterceptors();
        InterceptorStack interceptorStack =
            new InterceptorStack(
                instance.bean,
                remove,
                Operation.PRE_DESTROY,
                callbackInterceptors,
                instance.interceptors);

        interceptorStack.invoke();
      } catch (Throwable e) {
        logger.error(
            "An unexpected exception occured while invoking the ejbRemove method on the timed-out Stateful SessionBean instance",
            e);
      } finally {
        logger.info("Removing the timed-out stateful session bean instance " + instance.primaryKey);
        ThreadContext.exit(oldContext);
      }
    }
  public Object invoke(
      Object deployID,
      InterfaceType type,
      Class callInterface,
      Method callMethod,
      Object[] args,
      Object primKey)
      throws OpenEJBException {
    BeanContext beanContext = this.getBeanContext(deployID);

    if (beanContext == null)
      throw new OpenEJBException(
          "Deployment does not exist in this container. Deployment(id='"
              + deployID
              + "'), Container(id='"
              + containerID
              + "')");

    // Use the backup way to determine call type if null was supplied.
    if (type == null) type = beanContext.getInterfaceType(callInterface);

    Data data = (Data) beanContext.getContainerData();
    MethodType methodType = data.getMethodIndex().get(callMethod);
    methodType = (methodType != null) ? methodType : MethodType.BUSINESS;

    switch (methodType) {
      case CREATE:
        return createEJBObject(beanContext, callMethod, args, type);
      case REMOVE:
        return removeEJBObject(beanContext, primKey, callInterface, callMethod, args, type);
      default:
        return businessMethod(beanContext, primKey, callInterface, callMethod, args, type);
    }
  }
    public void afterLoad(Instance instance) throws SystemException, ApplicationException {
      BeanContext beanContext = instance.beanContext;

      ThreadContext threadContext =
          new ThreadContext(instance.beanContext, instance.primaryKey, Operation.ACTIVATE);
      ThreadContext oldContext = ThreadContext.enter(threadContext);
      try {
        Method remove =
            instance.bean instanceof SessionBean
                ? SessionBean.class.getMethod("ejbActivate")
                : null;

        List<InterceptorData> callbackInterceptors = beanContext.getCallbackInterceptors();
        InterceptorStack interceptorStack =
            new InterceptorStack(
                instance.bean,
                remove,
                Operation.ACTIVATE,
                callbackInterceptors,
                instance.interceptors);

        interceptorStack.invoke();
      } catch (Throwable callbackException) {
        discardInstance(threadContext);
        handleSystemException(
            threadContext.getTransactionPolicy(), callbackException, threadContext);
      } finally {
        ThreadContext.exit(oldContext);
      }
    }
Example #5
0
  private void removeEJBObject(
      final Method callMethod, final ThreadContext callContext, final InterfaceType interfaceType)
      throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();

    final TransactionPolicy txPolicy =
        createTransactionPolicy(
            beanContext.getTransactionType(callMethod, interfaceType), callContext);

    try {
      final EntityBean entityBean =
          (EntityBean) cmpEngine.loadBean(callContext, callContext.getPrimaryKey());
      if (entityBean == null) {
        throw new NoSuchObjectException(
            callContext.getBeanContext().getDeploymentID() + " " + callContext.getPrimaryKey());
      }
      ejbRemove(entityBean);
      cmpEngine.removeBean(callContext);
    } catch (final NoSuchObjectException e) {
      handleApplicationException(txPolicy, e, false);
    } catch (final Throwable e) { // handle reflection exception
      handleSystemException(txPolicy, e, callContext);
    } finally {
      afterInvoke(txPolicy, callContext);
    }
  }
    public void beforeStore(Instance instance) {
      BeanContext beanContext = instance.beanContext;

      ThreadContext threadContext =
          new ThreadContext(beanContext, instance.primaryKey, Operation.PASSIVATE);
      ThreadContext oldContext = ThreadContext.enter(threadContext);
      try {
        Method passivate =
            instance.bean instanceof SessionBean
                ? SessionBean.class.getMethod("ejbPassivate")
                : null;

        List<InterceptorData> callbackInterceptors = beanContext.getCallbackInterceptors();
        InterceptorStack interceptorStack =
            new InterceptorStack(
                instance.bean,
                passivate,
                Operation.PASSIVATE,
                callbackInterceptors,
                instance.interceptors);

        interceptorStack.invoke();

      } catch (Throwable e) {
        logger.error(
            "An unexpected exception occured while invoking the ejbPassivate method on the Stateful SessionBean instance",
            e);
      } finally {
        ThreadContext.exit(oldContext);
      }
    }
Example #7
0
 private EntityBean createNewInstance(final ThreadContext callContext) {
   final BeanContext beanContext = callContext.getBeanContext();
   try {
     return (EntityBean) beanContext.getCmpImplClass().newInstance();
   } catch (final Exception e) {
     throw new EJBException(
         "Unable to create new entity bean instance " + beanContext.getCmpImplClass(), e);
   }
 }
  public SingletonContainer(Object id, SecurityService securityService) throws OpenEJBException {
    this.containerID = id;
    this.securityService = securityService;

    instanceManager = new SingletonInstanceManager(securityService);

    for (BeanContext beanContext : deploymentRegistry.values()) {
      beanContext.setContainer(this);
    }
  }
 private Duration getAccessTimeout(BeanContext beanContext, Method callMethod) {
   Duration accessTimeout = beanContext.getAccessTimeout(callMethod);
   if (accessTimeout == null) {
     accessTimeout = beanContext.getAccessTimeout();
     if (accessTimeout == null) {
       accessTimeout = this.accessTimeout;
     }
   }
   return accessTimeout;
 }
  private void unregisterEntityManagers(Instance instance, ThreadContext callContext) {
    if (entityManagerRegistry == null) return;
    if (instance == null) return;

    BeanContext beanContext = callContext.getBeanContext();

    // register them
    entityManagerRegistry.removeEntityManagers(
        (String) beanContext.getDeploymentID(), instance.primaryKey);
  }
    public void afterCompletion(Status status) {
      Throwable firstException = null;
      for (Synchronization synchronization : registry.values()) {

        Instance instance = synchronization.instance;

        ThreadContext callContext =
            new ThreadContext(
                instance.beanContext, instance.primaryKey, Operation.AFTER_COMPLETION);
        callContext.setCurrentAllowedStates(null);
        ThreadContext oldCallContext = ThreadContext.enter(callContext);
        try {
          instance.setInUse(true);
          if (synchronization.isCallSessionSynchronization()) {

            BeanContext beanContext = instance.beanContext;
            List<InterceptorData> interceptors = beanContext.getCallbackInterceptors();
            InterceptorStack interceptorStack =
                new InterceptorStack(
                    instance.bean,
                    null,
                    Operation.AFTER_COMPLETION,
                    interceptors,
                    instance.interceptors);
            interceptorStack.invoke(status == Status.COMMITTED);
          }
          instance.setTransaction(null);
          releaseInstance(instance);
        } catch (InvalidateReferenceException inv) {
          // exception has alredy been handled
        } catch (Throwable e) {
          String message =
              "An unexpected system exception occured while invoking the afterCompletion method on the SessionSynchronization object";

          // [1] Log the exception or error
          logger.error(message, e);

          // Transaction is complete so can not be rolled back

          // [3] Discard the instance
          discardInstance(callContext);

          // [4] throw throw first exception to the client
          if (firstException == null) firstException = e;
        } finally {
          ThreadContext.exit(oldCallContext);
        }
      }

      if (firstException != null) {
        throw new RuntimeException(
            "An unexpected system exception occured while invoking the afterCompletion method on the SessionSynchronization object",
            firstException);
      }
    }
Example #12
0
  private ThreadContext createThreadContext(final EntityBean entityBean) {
    if (entityBean == null) {
      throw new NullPointerException("entityBean is null");
    }

    final BeanContext beanContext = getBeanContextByClass(entityBean.getClass());
    final KeyGenerator keyGenerator = beanContext.getKeyGenerator();
    final Object primaryKey = keyGenerator.getPrimaryKey(entityBean);

    return new ThreadContext(beanContext, primaryKey);
  }
    public void beforeCompletion() {
      for (Synchronization synchronization : registry.values()) {

        Instance instance = synchronization.instance;

        // don't call beforeCompletion when transaction is marked rollback only
        if (txPolicy.isRollbackOnly()) return;

        // only call beforeCompletion on beans with session synchronization
        if (!synchronization.isCallSessionSynchronization()) continue;

        // Invoke beforeCompletion
        ThreadContext callContext =
            new ThreadContext(
                instance.beanContext, instance.primaryKey, Operation.BEFORE_COMPLETION);
        callContext.setCurrentAllowedStates(null);
        ThreadContext oldCallContext = ThreadContext.enter(callContext);
        try {
          instance.setInUse(true);

          BeanContext beanContext = instance.beanContext;
          List<InterceptorData> interceptors = beanContext.getCallbackInterceptors();
          InterceptorStack interceptorStack =
              new InterceptorStack(
                  instance.bean,
                  null,
                  Operation.BEFORE_COMPLETION,
                  interceptors,
                  instance.interceptors);
          interceptorStack.invoke();

          instance.setInUse(false);
        } catch (InvalidateReferenceException e) {
          // exception has alredy been handled
        } catch (Exception e) {
          String message =
              "An unexpected system exception occured while invoking the beforeCompletion method on the SessionSynchronization object";

          // [1] Log the exception or error
          logger.error(message, e);

          // [2] Mark the transaction for rollback.
          txPolicy.setRollbackOnly(e);

          // [3] Discard the instance
          discardInstance(callContext);

          // [4] throw the java.rmi.RemoteException to the client
          throw new RuntimeException(message, e);
        } finally {
          ThreadContext.exit(oldCallContext);
        }
      }
    }
  public void deploy(BeanContext beanContext) throws OpenEJBException {
    String id = (String) beanContext.getDeploymentID();
    synchronized (this) {
      deploymentRegistry.put(id, beanContext);
      beanContext.setContainer(this);
    }

    EjbTimerService timerService = beanContext.getEjbTimerService();
    if (timerService != null) {
      timerService.start();
    }
  }
  public Instance getInstance(final ThreadContext callContext) throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();
    Data data = (Data) beanContext.getContainerData();
    AtomicReference<Future<Instance>> singleton = data.singleton;
    try {
      // Has the singleton been created yet?
      // If there is a Future object in the AtomicReference, then
      // it's either been created or is being created now.
      Future<Instance> singletonFuture = singleton.get();
      if (singletonFuture != null) return singletonFuture.get();

      // The singleton has not been created nor is being created
      // We will construct this FutureTask and compete with the
      // other threads for the right to create the singleton
      FutureTask<Instance> task =
          new FutureTask<Instance>(
              new Callable<Instance>() {
                public Instance call() throws Exception {
                  return createInstance(callContext, beanContext);
                }
              });

      do {
        // If our FutureTask was the one to win the slot
        // than we are the ones responsible for creating
        // the singleton while the others wait.
        if (singleton.compareAndSet(null, task)) {
          task.run();
        }

        // If we didn't win the slot and no other FutureTask
        // has been set by a different thread, than we need
        // to try again.
      } while ((singletonFuture = singleton.get()) == null);

      // At this point we can safely return the singleton
      return singletonFuture.get();

    } catch (InterruptedException e) {
      Thread.interrupted();
      throw new ApplicationException(
          new NoSuchEJBException("Singleton initialization interrupted").initCause(e));
    } catch (ExecutionException e) {
      Throwable throwable = e.getCause();
      if (throwable instanceof ApplicationException) {
        throw (ApplicationException) throwable;
      }

      throw new ApplicationException(
          new NoSuchEJBException("Singleton initialization failed").initCause(e.getCause()));
    }
  }
  /** Insure that timer methods can be invoked for the current operation on this Context. */
  private void checkState() throws IllegalStateException, NoSuchObjectLocalException {
    final BeanContext beanContext = ThreadContext.getThreadContext().getBeanContext();
    final BaseContext context = (BaseContext) beanContext.get(EJBContext.class);
    context.check(BaseContext.Call.timerMethod);

    if (timerData.isCancelled()) {
      throw new NoSuchObjectLocalException("Timer has been cancelled");
    }

    if (timerData.isExpired()) {
      throw new NoSuchObjectLocalException("The timer has expired");
    }
  }
Example #17
0
  private Object businessMethod(
      final Method callMethod,
      final Method runMethod,
      final Object[] args,
      final ThreadContext callContext,
      final InterfaceType interfaceType)
      throws OpenEJBException {
    final BeanContext beanContext = callContext.getBeanContext();

    final TransactionPolicy txPolicy =
        createTransactionPolicy(
            beanContext.getTransactionType(callMethod, interfaceType), callContext);

    final EntityBean bean;
    Object returnValue = null;

    entrancyTracker.enter(beanContext, callContext.getPrimaryKey());
    try {
      bean = (EntityBean) cmpEngine.loadBean(callContext, callContext.getPrimaryKey());
      if (bean == null) {
        throw new NoSuchObjectException(
            beanContext.getDeploymentID() + " : " + callContext.getPrimaryKey());
      }

      returnValue = runMethod.invoke(bean, args);

      // when there is not transaction, merge the data from the bean back into the cmp engine
      cmpEngine.storeBeanIfNoTx(callContext, bean);
    } catch (final NoSuchObjectException e) {
      handleApplicationException(txPolicy, e, false);
    } catch (Throwable e) {
      if (e instanceof InvocationTargetException) {
        e = ((InvocationTargetException) e).getTargetException();
      }

      final ExceptionType type = callContext.getBeanContext().getExceptionType(e);
      if (type == ExceptionType.SYSTEM) {
        /* System Exception ****************************/
        handleSystemException(txPolicy, e, callContext);
      } else {
        /* Application Exception ***********************/
        handleApplicationException(txPolicy, e, type == ExceptionType.APPLICATION_ROLLBACK);
      }
    } finally {
      entrancyTracker.exit(beanContext, callContext.getPrimaryKey());
      afterInvoke(txPolicy, callContext);
    }

    return returnValue;
  }
Example #18
0
  private void cancelTimers(final ThreadContext threadContext) {
    final BeanContext beanContext = threadContext.getBeanContext();
    final Object primaryKey = threadContext.getPrimaryKey();

    // stop timers
    if (primaryKey != null && beanContext.getEjbTimerService() != null) {
      final EjbTimerService timerService = beanContext.getEjbTimerService();
      if (timerService != null && timerService instanceof EjbTimerServiceImpl) {
        for (final Timer timer : beanContext.getEjbTimerService().getTimers(primaryKey)) {
          timer.cancel();
        }
      }
    }
  }
  public void undeploy(BeanContext beanContext) {
    Data data = (Data) beanContext.getContainerData();
    if (data == null) return;

    MBeanServer server = LocalMBeanServer.get();
    for (ObjectName objectName : data.jmxNames) {
      try {
        server.unregisterMBean(objectName);
      } catch (Exception e) {
        logger.error("Unable to unregister MBean " + objectName);
      }
    }

    beanContext.setContainerData(null);
  }
  private Instance createInstance(ThreadContext callContext, BeanContext beanContext)
      throws ApplicationException {
    try {
      initializeDependencies(beanContext);

      final InstanceContext context = beanContext.newInstance();

      if (context.getBean() instanceof SessionBean) {

        final Operation originalOperation = callContext.getCurrentOperation();
        try {
          callContext.setCurrentOperation(Operation.CREATE);
          final Method create = beanContext.getCreateMethod();
          final InterceptorStack ejbCreate =
              new InterceptorStack(
                  context.getBean(),
                  create,
                  Operation.CREATE,
                  new ArrayList<InterceptorData>(),
                  new HashMap());
          ejbCreate.invoke();
        } finally {
          callContext.setCurrentOperation(originalOperation);
        }
      }

      ReadWriteLock lock;
      if (beanContext.isBeanManagedConcurrency()) {
        // Bean-Managed Concurrency
        lock = new BeanManagedLock();
      } else {
        // Container-Managed Concurrency
        lock = new ReentrantReadWriteLock();
      }

      return new Instance(
          context.getBean(), context.getInterceptors(), context.getCreationalContext(), lock);
    } catch (Throwable e) {
      if (e instanceof java.lang.reflect.InvocationTargetException) {
        e = ((java.lang.reflect.InvocationTargetException) e).getTargetException();
      }
      String t =
          "The bean instance " + beanContext.getDeploymentID() + " threw a system exception:" + e;
      logger.error(t, e);
      throw new ApplicationException(
          new NoSuchEJBException("Singleton failed to initialize").initCause(e));
    }
  }
Example #21
0
 @Override
 public void start(final BeanContext beanContext) throws OpenEJBException {
   final EjbTimerService timerService = beanContext.getEjbTimerService();
   if (timerService != null) {
     timerService.start();
   }
 }
  private Index<EntityManagerFactory, JtaEntityManagerRegistry.EntityManagerTracker>
      createEntityManagers(BeanContext beanContext) {
    // create the extended entity managers
    Index<EntityManagerFactory, Map> factories = beanContext.getExtendedEntityManagerFactories();
    Index<EntityManagerFactory, JtaEntityManagerRegistry.EntityManagerTracker> entityManagers =
        null;
    if (factories != null && factories.size() > 0) {
      entityManagers =
          new Index<EntityManagerFactory, JtaEntityManagerRegistry.EntityManagerTracker>(
              new ArrayList<EntityManagerFactory>(factories.keySet()));
      for (Map.Entry<EntityManagerFactory, Map> entry : factories.entrySet()) {
        EntityManagerFactory entityManagerFactory = entry.getKey();
        Map properties = entry.getValue();

        JtaEntityManagerRegistry.EntityManagerTracker entityManagerTracker =
            entityManagerRegistry.getInheritedEntityManager(entityManagerFactory);
        EntityManager entityManager;
        if (entityManagerTracker == null) {
          if (properties != null) {
            entityManager = entityManagerFactory.createEntityManager(properties);
          } else {
            entityManager = entityManagerFactory.createEntityManager();
          }
          entityManagerTracker = new JtaEntityManagerRegistry.EntityManagerTracker(entityManager);
        } else {
          entityManagerTracker.incCounter();
        }
        entityManagers.put(entityManagerFactory, entityManagerTracker);
      }
    }
    return entityManagers;
  }
  public void undeploy(BeanContext beanContext) {

    EjbTimerService timerService = beanContext.getEjbTimerService();
    if (timerService != null) {
      timerService.stop();
    }

    instanceManager.undeploy(beanContext);

    synchronized (this) {
      String id = (String) beanContext.getDeploymentID();
      beanContext.setContainer(null);
      beanContext.setContainerData(null);
      deploymentRegistry.remove(id);
    }
  }
Example #24
0
  public int update(
      final BeanContext beanContext, final String methodSignature, final Object... args)
      throws FinderException {
    final String signature = beanContext.getAbstractSchemaName() + "." + methodSignature;

    // exectue the update query
    return cmpEngine.executeUpdateQuery(beanContext, signature, args);
  }
Example #25
0
  @Override
  public void undeploy(final BeanContext beanContext) throws OpenEJBException {
    synchronized (this) {
      deploymentsById.remove(beanContext.getDeploymentID());
      beansByClass.remove(beanContext.getCmpImplClass());

      try {
        final Field field = beanContext.getCmpImplClass().getField("deploymentInfo");
        field.set(null, null);
      } catch (final Exception e) {
        // ignore
      }

      beanContext.setContainer(null);
      beanContext.setContainerData(null);
    }
  }
  @Test
  public void testRollback() throws Exception {
    SystemInstance.init(new Properties());
    final BeanContext cdi =
        new BeanContext(
            "foo",
            null,
            new ModuleContext(
                "foo",
                null,
                "bar",
                new AppContext("foo", SystemInstance.get(), null, null, null, false),
                null,
                null),
            Object.class,
            null,
            new HashMap<String, String>());
    cdi.addApplicationException(AE1.class, true, true);
    cdi.addApplicationException(AE3.class, true, false);
    cdi.addApplicationException(AE6.class, false, true);

    assertEquals(ExceptionType.APPLICATION_ROLLBACK, cdi.getExceptionType(new AE1()));
    assertEquals(ExceptionType.APPLICATION_ROLLBACK, cdi.getExceptionType(new AE2()));
    assertEquals(ExceptionType.APPLICATION_ROLLBACK, cdi.getExceptionType(new AE3()));
    assertEquals(ExceptionType.SYSTEM, cdi.getExceptionType(new AE4()));
    assertEquals(ExceptionType.SYSTEM, cdi.getExceptionType(new AE5()));
    assertEquals(ExceptionType.APPLICATION, cdi.getExceptionType(new AE6()));
    assertEquals(ExceptionType.APPLICATION, cdi.getExceptionType(new AE7()));
  }
  public StatelessContainer(
      Object id,
      SecurityService securityService,
      Duration accessTimeout,
      Duration closeTimeout,
      Pool.Builder poolBuilder,
      int callbackThreads) {
    this.containerID = id;
    this.securityService = securityService;

    instanceManager =
        new StatelessInstanceManager(
            securityService, accessTimeout, closeTimeout, poolBuilder, callbackThreads);

    for (BeanContext beanContext : deploymentRegistry.values()) {
      beanContext.setContainer(this);
    }
  }
  private void initializeDependencies(BeanContext beanContext) throws OpenEJBException {
    SystemInstance systemInstance = SystemInstance.get();
    ContainerSystem containerSystem = systemInstance.getComponent(ContainerSystem.class);
    for (String dependencyId : beanContext.getDependsOn()) {
      BeanContext dependencyContext = containerSystem.getBeanContext(dependencyId);
      if (dependencyContext == null) {
        throw new OpenEJBException(
            "Deployment does not exist. Deployment(id='" + dependencyContext + "')");
      }

      final Object containerData = dependencyContext.getContainerData();

      // Bean may not be a singleton or may be a singleton
      // managed by a different container implementation
      if (containerData instanceof Data) {
        Data data = (Data) containerData;

        data.initialize();
      }
    }
  }
  public synchronized void deploy(BeanContext beanContext) throws OpenEJBException {
    Map<Method, MethodType> methods = getLifecycleMethodsOfInterface(beanContext);

    deploymentsById.put(beanContext.getDeploymentID(), beanContext);
    beanContext.setContainer(this);
    Data data = new Data(new Index<Method, MethodType>(methods));
    beanContext.setContainerData(data);

    // Create stats interceptor
    StatsInterceptor stats = new StatsInterceptor(beanContext.getBeanClass());
    beanContext.addSystemInterceptor(stats);

    MBeanServer server = LocalMBeanServer.get();

    ObjectNameBuilder jmxName = new ObjectNameBuilder("openejb.management");
    jmxName.set("J2EEServer", "openejb");
    jmxName.set("J2EEApplication", null);
    jmxName.set("EJBModule", beanContext.getModuleID());
    jmxName.set("StatelessSessionBean", beanContext.getEjbName());
    jmxName.set("j2eeType", "");
    jmxName.set("name", beanContext.getEjbName());

    // register the invocation stats interceptor
    try {
      ObjectName objectName = jmxName.set("j2eeType", "Invocations").build();
      server.registerMBean(new ManagedMBean(stats), objectName);
      data.jmxNames.add(objectName);
    } catch (Exception e) {
      logger.error("Unable to register MBean ", e);
    }

    try {
      final Context context = beanContext.getJndiEnc();
      context.bind("comp/EJBContext", sessionContext);
    } catch (NamingException e) {
      throw new OpenEJBException("Failed to bind EJBContext", e);
    }

    beanContext.set(EJBContext.class, this.sessionContext);
  }
 private void initialize(BeanContext beanContext) throws OpenEJBException {
   try {
     ThreadContext callContext = new ThreadContext(beanContext, null);
     ThreadContext old = ThreadContext.enter(callContext);
     try {
       getInstance(callContext);
     } finally {
       ThreadContext.exit(old);
     }
   } catch (OpenEJBException e) {
     throw new OpenEJBException("Singleton startup failed: " + beanContext.getDeploymentID(), e);
   }
 }