docs: private void processMetadataByBeanType(BeanMetaData bmd,
                                             int beanType) // F743-17630
                      throws ContainerException, EJBConfigurationException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(tc, "processMetadataByBeanType");
          }
  
          switch (beanType) {
  
              case Session_Type:
  
                  // Set session timeout.  Session timeout only applies to Stateful session beans.
                  // During server startup the system properties are checked and set, if the system
                  // property for stateful session bean timeout was not set, the default value of
                  // 10 minutes is set in the ContainerProperties.DefaultStatefulSessionTimeout.
                  // Initially use this value, then check if the timeout is set in
                  // ibm-ejb-jar-ext.xmi file, then take that value.     d627044
                  if (bmd.type == InternalConstants.TYPE_STATEFUL_SESSION) {
                      // F743-14726  d627044
                      // Set initially to the value of ContainerProperties.DefaultStatefulSessionTimeout
                      bmd.sessionTimeout = DefaultStatefulSessionTimeout;
                      boolean sessionTimeoutExtensionFound = processSessionExtensionTimeout(bmd); // F743-6605, F743-18775
                      // begin F743-6605
  
                      // stateful-timeout DD in ejb-jar.xml and/or @StatefulTimeout annotation will
                      // override session timeout in the SessionExtension, if present.
                      // XML value takes precedence over annotation
                      // Retrieve the stateful-timeout value, if one was computed by the WCCM config reader
  
                      Session session = (Session) bmd.wccm.enterpriseBean;
                      com.ibm.ws.javaee.dd.ejb.StatefulTimeout statefulTimeoutXML = session == null ? null : session.getStatefulTimeout();
                      if (statefulTimeoutXML != null) {
                          long statefulTimeoutXMLTimeout = statefulTimeoutXML.getTimeout();
                          TimeUnit statefulTimeoutXMLUnit = statefulTimeoutXML.getUnitValue();
  
                          bmd.sessionTimeout = MethodAttribUtils.timeUnitToMillis(statefulTimeoutXMLTimeout, statefulTimeoutXMLUnit, false, bmd);
  
                          if (isTraceOn && tc.isDebugEnabled()) {
                              if (sessionTimeoutExtensionFound) {
                                  Tr.debug(tc, "Overriding session timeout " + bmd.sessionTimeout +
                                               " found in extension with stateful-timeout with " +
                                               statefulTimeoutXMLTimeout + " " + statefulTimeoutXMLUnit +
                                               " found in ejb-jar.xml.");
                              } else {
                                  Tr.debug(tc, "Using stateful timeout " + bmd.sessionTimeout + " from XML for bean " + bmd.getName());
                              }
  
                          }
  
                      } else {
  
                          // XML value not found, so look for @StatefulTimeout annotation
  
                          StatefulTimeout statefulTimeout = bmd.enterpriseBeanClass.getAnnotation(javax.ejb.StatefulTimeout.class);
                          if (statefulTimeout != null) {
  
                              // F743-14726  d627044
                              // Set to the value of ContainerProperties.DefaultStatefulSessionTimeout
                              long statefulTimeoutAnnTimeout = DefaultStatefulSessionTimeout; // F743-6605.1  F743-14726  d627044
                              statefulTimeoutAnnTimeout = statefulTimeout.value();
                              TimeUnit unit = statefulTimeout.unit();
                              bmd.sessionTimeout = MethodAttribUtils.timeUnitToMillis(statefulTimeoutAnnTimeout, unit, true, bmd);
  
                              if (isTraceOn && tc.isDebugEnabled()) {
                                  if (sessionTimeoutExtensionFound) {
                                      Tr.debug(tc, "Overriding session timeout " + bmd.sessionTimeout +
                                                   " found in extension with StatefulTimeout with " +
                                                   statefulTimeoutAnnTimeout + " " + unit + " found in bean-level annotation.");
                                  } else {
                                      Tr.debug(tc, "Using stateful timeout " + bmd.sessionTimeout + " from annotation for bean " + bmd.getName()); // F743-6605.1
                                  }
                              }
  
                          }
  
                      }
                      // end F743-6605
  
                      //LIDB2018-1 begins
                      // Check if this SFSB is a startup bean by looking at whether
                      // home interface is the startup bean home interface.
                      if ((bmd.homeInterfaceClassName != null && bmd.homeInterfaceClassName.equals("com.ibm.websphere.startupservice.AppStartUpHome")) ||
                          (bmd.localHomeInterfaceClassName != null && bmd.localHomeInterfaceClassName.equals("com.ibm.websphere.startupservice.AppStartUpHome"))) {
                          // It is a startup bean, so ensure failover is disabled since we never
                          // want to failover a startup bean.
                          bmd.ivSFSBFailover = false; //d210506
                      } else {
                          // Not a startup bean, so determine if failover should be enabled.
                          // d361748 start of change.
                          EJBModuleMetaDataImpl mmd = bmd._moduleMetaData;
                          if (mmd.ivSfsbFailover) {
                              if (!bmd.passivationCapable) {
                                  Tr.info(tc, "FAILOVER_DISABLED_NOT_PASSIVATION_CAPABLE_CNTR0331I",
                                          new Object[] { bmd.enterpriseBeanName,
                                                         bmd._moduleMetaData.ivName,
                                                         bmd._moduleMetaData.ivAppName });
                              } else {
                                  // SFSB failover is enabled for this module, so initialize
                                  // BeanMetaData with SFSB failover flag and reference to
                                  // the SfFailoverClient object to use for replication of SFSB data.
                                  // The module meta data has the failover string ID that was used
                                  // to create and cache the SfFailoverClient object for this module.
                                  String failoverId = mmd.ivFailoverInstanceId;
                                  SfFailoverCache failover = bmd.container.getSfFailoverCache();
                                  bmd.ivSfFailoverClient = failover.getCachedSfFailoverClient(failoverId);
                                  if (bmd.ivSfFailoverClient != null) {
                                      bmd.ivSFSBFailover = true;
                                  } else {
                                      // This should never happen if the admin console GUI is used to
                                      // configure SFSB failover. However, if customer edits the deployment.xml
                                      // and/or server.xml file directly, then we could end up in this
                                      // code path.  So log warning message to inform administrator that
                                      // we are missing a default failover setting to use and that SFSB
                                      // failover is not enabled for this bean.
                                      bmd.ivSFSBFailover = false;
                                      // CNTR0097W: Memory to memory replication settings for EJB container is missing.
                                      Tr.warning(tc, "MISSING_CONTAINER_DRSSETTINGS_CNTR0097W");
                                  }
                              }
                          } // d361748 end of change.
  
                      } //LIDB2018-1 ends
                  } else if (bmd.type == InternalConstants.TYPE_SINGLETON_SESSION) {
                      // Determine singleton session bean concurrency control.
                      processSingletonConcurrencyManagementType(bmd);
                  }
  
                  // Bean reentrant flag is set below according to bean type.
                  bmd.reentrant = false;
  
                  // TODO: MLS - Is removeTxAttr on bmd really used any more?
                  if (bmd.usesBeanManagedTx) { // LIDB2257.19
                      bmd.removeTxAttr = BeanMetaData.TX_ATTRIBUTE_TYPE_BEAN_MANAGED;
                  } else {
                      bmd.removeTxAttr = BeanMetaData.TX_ATTRIBUTE_TYPE_NOT_SUPPORTED;
                  }
  
                  processSessionExtension(bmd); // F743-18775
  
                  bmd.usesBeanManagedAS = (bmd.container).getContainerExtensionFactory().isActivitySessionBeanManaged(bmd.usesBeanManagedTx); // LIDB441.5, d126204.2
  
                  bmd.pKeyClass = null;
  
                  break;
  
              case Entity_Type:
  
                  bmd.usesBeanManagedAS = false;
                  bmd.sessionTimeout = 0;
  
                  // primary key class is loader here rather than in
                  // loadCustomerProvidedClasses because customers only
                  // supply key implementations for entity beans
                  Entity entity = (Entity) bmd.wccm.enterpriseBean;
                  String primaryKeyClassName = entity.getPrimaryKeyName();
  
                  try {
                      bmd.pKeyClass = bmd.classLoader.loadClass(primaryKeyClassName); //d494984
                  } catch (ClassNotFoundException ex) {
                      FFDCFilter.processException(ex, CLASS_NAME + ".processMetadataByBeanType",
                                                  "3392", this);
                      if (isTraceOn && tc.isEventEnabled())
                          Tr.event(tc, "Failed to initialize BeanMetaData instance", ex);
                      EJBConfigurationException ecex;
                      ecex = new EJBConfigurationException("Bean class " + primaryKeyClassName + " could not be found or loaded", ex);
                      Tr.error(tc, "BEANCLASS_NOT_FOUND_CNTR0075E", primaryKeyClassName); //d494984
                      throw ecex;
                  }
                  if (isTraceOn && tc.isDebugEnabled()) {
                      Tr.debug(tc, " **** bean primary key class = " +
                                   primaryKeyClassName);
                  }
  
                  bmd.reentrant = entity.isReentrant();
                  processEntityExtension(bmd); // F743-18775
                  break;
  
              case Message_Type:
  
                  // Message Driven Beans are required to be non-reentrant
                  // as stated in 15.8.4 of EJB 2.1 specification.
                  bmd.reentrant = false;
  
                  bmd.usesBeanManagedAS = bmd.container.getContainerExtensionFactory().isActivitySessionBeanManaged(bmd.usesBeanManagedTx); // LIDB441.5, d126204.2
  
                  bmd.pKeyClass = null;
  
                  // d244832 start of change
                  // Verify MDB bean implements the message listener interface required by messaging type.
                  // Note:  Starting in EJB3 the MessageListenerInterface is no longer required to be on
                  // the implements clause of the EJB, so this check is only for prior versions.  //450391
                  if (!(bmd.localInterfaceClass.isAssignableFrom(bmd.enterpriseBeanAbstractClass)) &&
                      (bmd.getEJBModuleVersion() < BeanMetaData.J2EE_EJB_VERSION_3_0)) {
                      // Whoops, the EJB 2.x specification says the MDB class must implement,
                      // directly or indirectly, the message listener interface required by the
                      // messaging type that it supports. In the case of JMS, this is the
                      // javax.jms.MessageListener interface.  So let's cause MDB to fail to start
                      // in order to avoid the problem of JCA 1.5 RA encountering a ClassCastException
                      // when it tries to call a method on MDB instance that does not implement
                      // the messaging listener interface.
  
                      // Log CNTR0112E: The user-provided class "{0}" must implement the "{1}" interface.
                      Tr.error(tc, "MDB_MUST_IMPLEMENT_INTERFACE_CNTR0112E", new Object[] { bmd.enterpriseBeanClassName, bmd.localInterfaceClass.getName() });
                      throw new EJBConfigurationException("MDB " + bmd.enterpriseBeanClassName
                                                          + " must implement interface "
                                                          + bmd.localInterfaceClass.getName());
  
                  } //d244832 end of change
  
                  break;
  
              case Managed_Type:
  
                  // There is no type specific processing for Managed Beans F743-34301
  
                  break;
  
              default:
  
                  throw new ContainerException("Unknown BeanType");
          }
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(tc, "processMetadataByBeanType");
          }
  
      }