@Override
  public void deploy(DeploymentUnit unit) throws DeploymentException {
    log.debug("Deploying rails app as rack: " + unit);
    RailsApplicationMetaData railsAppMetaData = unit.getAttachment(RailsApplicationMetaData.class);

    try {
      RackApplicationMetaData rackMetaData = unit.getAttachment(RackApplicationMetaData.class);

      log.info(rackMetaData);
      log.info(railsAppMetaData);

      if (railsAppMetaData.isRails3()) {
        log.debug("Configuring up a rails 3 application: " + unit);
        rackMetaData.setRackUpScriptLocation("config.ru");
      } else {
        log.debug("Configuring up a rails 2 application: " + unit);
        rackMetaData.setRackUpScript(getRackUpScript(rackMetaData.getContextPath()));
        rackMetaData.setRackUpScriptLocation(null);
      }

      rackMetaData.setStaticPathPrefix(STATIC_PATH_PREFIX);
      log.debug("Configured rack deployment: " + unit + "\n" + rackMetaData);
    } catch (Exception e) {
      throw new DeploymentException(e);
    }
  }
  public void deploy(DeploymentUnit unit) throws DeploymentException {
    Set<? extends RubyEndpointMetaData> allMetaData =
        unit.getAllMetaData(RubyEndpointMetaData.class);

    if (allMetaData.size() == 0) {
      return;
    }

    log.debug("deploying for: " + unit);

    BeanMetaData busMetaData =
        unit.getAttachment(BeanMetaData.class + "$cxf.bus", BeanMetaData.class);

    RubyDynamicClassLoader classLoader = unit.getAttachment(RubyDynamicClassLoader.class);

    for (RubyEndpointMetaData endpointMetaData : allMetaData) {
      String beanName = getBeanName(unit, endpointMetaData.getName());
      BeanMetaDataBuilder builder =
          BeanMetaDataBuilder.createBuilder(beanName, RubyTypeSpace.class.getName());

      builder.addPropertyMetaData("rubyPath", "jboss/databinding/" + endpointMetaData.getName());
      builder.addPropertyMetaData("wsdlLocation", endpointMetaData.getWsdlLocation());
      builder.addPropertyMetaData("rubyDynamicClassLoader", classLoader);

      ValueMetaData busInjection = builder.createInject(busMetaData.getName());
      builder.addPropertyMetaData("bus", busInjection);

      BeanMetaData beanMetaData = builder.getBeanMetaData();
      unit.addAttachment(
          BeanMetaData.class.getName() + "$databinding." + endpointMetaData.getName(),
          beanMetaData,
          BeanMetaData.class);
    }
  }
  /**
   * Process the deployment unit and deploy appropriate MC beans (see details below) if it
   * corresponds to a no-interface view deployment.
   *
   * <p>If any beans in the unit are eligible for no-interface view, then internally this method
   * creates a {@link NoInterfaceViewJNDIBinderFacade} MC bean for the no-interface view.
   *
   * <p>The {@link NoInterfaceViewJNDIBinderFacade}, thus created, will be dependent on the {@link
   * ControllerState#DESCRIBED} state of the container (endpoint) MC bean. This way, we ensure that
   * this {@link NoInterfaceViewJNDIBinderFacade} will be deployed only after the corresponding
   * container MC bean moves to {@link ControllerState#DESCRIBED} state.
   */
  public void deploy(DeploymentUnit unit) throws DeploymentException {

    if (logger.isTraceEnabled()) {
      logger.trace("Deploying unit " + unit.getName());
    }
    // get processed metadata
    JBossMetaData metaData = unit.getAttachment(INPUT, JBossMetaData.class);
    if (metaData == null) {
      if (logger.isTraceEnabled()) logger.trace("No JBossMetadata for unit : " + unit.getName());
      return;
    }
    // work on the ejbs
    JBossEnterpriseBeansMetaData beans = metaData.getEnterpriseBeans();
    for (JBossEnterpriseBeanMetaData bean : beans) {
      if (bean.isSession()) {
        if (logger.isTraceEnabled()) {
          logger.trace(
              "Found bean of type session: " + bean.getEjbClass() + " in unit " + unit.getName());
        }
        // too bad
        if (bean instanceof JBossSessionBean31MetaData) {
          // Process for no-interface view
          deploy(unit, (JBossSessionBean31MetaData) bean);
        }
      }
    }
  }
  @Override
  public void deploy(DeploymentUnit unit) throws DeploymentException {
    TorqueBoxMetaData externalMetaData =
        unit.getAttachment(TorqueBoxMetaData.EXTERNAL, TorqueBoxMetaData.class);
    if (log.isTraceEnabled()) {
      log.trace("External: " + externalMetaData);
    }

    if (externalMetaData == null) {
      return;
    }

    TorqueBoxMetaData metaData = unit.getAttachment(TorqueBoxMetaData.class);
    if (log.isTraceEnabled()) {
      log.trace("Internal: " + metaData);
    }

    if (metaData == null) {
      unit.addAttachment(TorqueBoxMetaData.class, externalMetaData);
      return;
    }
    try {
      TorqueBoxMetaData mergedMetaData = externalMetaData.overlayOnto(metaData);
      if (log.isTraceEnabled()) {
        log.trace("Merged: " + mergedMetaData);
      }
      unit.addAttachment(TorqueBoxMetaData.class, mergedMetaData);
    } catch (ClassCastException e) {
      throw new DeploymentException(
          "Incompatible structures in external and internal deployment descriptors", e);
    }
  }
  protected boolean doAccepts(DeploymentUnit unit) {
    // ejbs
    JBossMetaData jbm = unit.getAttachment(JBossMetaData.class);
    if (jbm != null && jbm.isMetadataComplete()) return false;

    // wars
    JBossWebMetaData jwbm = unit.getAttachment(JBossWebMetaData.class);
    if (jwbm != null && jwbm.isMetadataComplete()) return false;

    return true;
  }
 @Override
 public void deploy(DeploymentUnit unit) throws DeploymentException {
   if (unit.getAllMetaData(MessageProcessorMetaData.class).isEmpty()) {
     return;
   }
   PoolMetaData pool = AttachmentUtils.getAttachment(unit, "messaging", PoolMetaData.class);
   if (pool == null) {
     RubyApplicationMetaData envMetaData = unit.getAttachment(RubyApplicationMetaData.class);
     boolean devMode = envMetaData != null && envMetaData.isDevelopmentMode();
     pool = devMode ? new PoolMetaData("messaging", 1, 2) : new PoolMetaData("messaging");
     pool.setInstanceFactoryName(this.instanceFactoryName);
     AttachmentUtils.multipleAttach(unit, pool, "messaging");
   }
 }
  @Override
  protected void internalDeploy(DeploymentUnit unit) throws DeploymentException {
    if (!isJavaEEModule(unit)) return;

    // appName is either the name of the JavaEE application or null for a stand-alone JavaEE module
    String appName = informer.getApplicationName(unit);
    String moduleName = informer.getModuleName(unit);

    // create JavaEEModule bean
    String name = "jboss.naming:";
    if (appName != null) name += "application=" + appName + ",";
    name += "module=" + moduleName;
    BeanMetaDataBuilder builder =
        BeanMetaDataBuilderFactory.createBuilder(name, MCJavaEEModule.class.getName())
            //         .addAnnotation(annotation(DeploymentScope.class, moduleName))
            .addConstructorParameter(String.class.getName(), moduleName)
        //         .addAlias("java:module")
        ;
    if (appName != null) {
      //         builder.addAnnotation(annotation(ApplicationScope.class, appName));
      //         AbstractInjectionValueMetaData javaApp = new
      // AbstractInjectionValueMetaData("java:app");
      //         javaApp.setSearch(new ParentsLookupStrategy());
      AbstractInjectionValueMetaData javaApp =
          new AbstractInjectionValueMetaData("jboss.naming:application=" + appName);
      builder.addConstructorParameter(JavaEEApplication.class.getName(), javaApp);
    } else builder.addConstructorParameter(JavaEEApplication.class.getName(), (Object) null);
    builder.addPropertyMetaData("nameSpaces", builder.createInject("NameSpaces"));

    unit.addAttachment(BeanMetaData.class + "." + name, builder.getBeanMetaData());
  }
  public void deploy(DeploymentUnit unit) throws DeploymentException {
    RubyApplicationMetaData rubyAppMetaData = unit.getAttachment(RubyApplicationMetaData.class);

    if (rubyAppMetaData.getEnvironmentName() == null
        || rubyAppMetaData.getEnvironmentName().trim().equals("")) {
      rubyAppMetaData.setEnvironmentName(DEFAULT_ENVIRONMENT_NAME);
    }
  }
    public void undeploy(DeploymentUnit unit, TestComponentMetaDataContainer deployment) {
      List<TestComponentMetaData> tests = deployment.componentMetaData;
      if (tests == null) return;

      for (TestComponentMetaData test : tests) {
        unit.removeComponent(test.name);
      }
    }
 protected void assertNoClassLoader(DeploymentUnit unit) throws Exception {
   try {
     unit.getClassLoader();
     fail("Should not be here!");
   } catch (Exception e) {
     checkThrowable(IllegalStateException.class, e);
   }
 }
  /**
   * A template pattern implementation of the deploy() method. This method calls the {@link
   * #performDeploy(WebApplication, String, WebDescriptorParser) performDeploy()} method to perform
   * the container specific deployment steps and registers the returned WebApplication in the
   * deployment map. The steps performed are:
   *
   * <p>ClassLoader appClassLoader = thread.getContextClassLoader(); URLClassLoader warLoader =
   * URLClassLoader.newInstance(empty, appClassLoader); thread.setContextClassLoader(warLoader);
   * WebDescriptorParser webAppParser = ...; WebMetaData metaData = di.metaData; // Create JACC
   * permissions, contextID, etc. ... WebApplication warInfo = new WebApplication(metaData);
   * performDeploy(warInfo, warUrl, webAppParser); deploymentMap.put(warUrl, warInfo);
   * thread.setContextClassLoader(appClassLoader);
   *
   * <p>The subclass performDeploy() implementation needs to invoke processEnc(loader, warInfo) to
   * have the JNDI java:comp/env namespace setup before any web app component can access this
   * namespace.
   *
   * <p>Also, an MBean for each servlet deployed should be created and its JMX ObjectName placed
   * into the DeploymentInfo.mbeans list so that the JSR77 layer can create the approriate model
   * view. The servlet MBean needs to provide access to the min, max and total time in milliseconds.
   * Expose this information via MinServiceTime, MaxServiceTime and TotalServiceTime attributes to
   * integrate seemlessly with the JSR77 factory layer.
   *
   * @param unit The deployment info that contains the context-root element value from the J2EE
   *     application/module/web application.xml descriptor. This may be null if war was is not being
   *     deployed as part of an enterprise application. It also contains the URL of the web
   *     application war.
   */
  public synchronized WebApplication start(DeploymentUnit unit, JBossWebMetaData metaData)
      throws Exception {
    Thread thread = Thread.currentThread();
    ClassLoader appClassLoader = thread.getContextClassLoader();
    WebApplication webApp = null;
    try {
      // Create a classloader for the war to ensure a unique ENC
      ClassLoader warLoader = unit.getClassLoader();
      thread.setContextClassLoader(warLoader);
      String webContext = metaData.getContextRoot();

      // Get the war URL
      URL warUrl = unit.getAttachment("org.jboss.web.expandedWarURL", URL.class);
      if (warUrl == null && unit instanceof VFSDeploymentUnit) {
        VFSDeploymentUnit vdu = VFSDeploymentUnit.class.cast(unit);
        warUrl = VFSUtils.getRealURL(vdu.getRoot());
      }

      // Dynamic WebMetaData deployments might not provide an URL
      // We use the DEploymentUnit name as identifier instead.
      // The JAXWS Endpoint API for example does this.
      String warURLString = (warUrl != null ? warUrl.toExternalForm() : unit.getName());

      // Strip any jar: url syntax. This should be be handled by the vfs
      if (warURLString.startsWith("jar:"))
        warURLString = warURLString.substring(4, warURLString.length() - 2);

      log.debug("webContext: " + webContext);
      log.debug("warURL: " + warURLString);

      // Register the permissions with the JACC layer
      String contextID = metaData.getJaccContextID();
      if (contextID == null) contextID = unit.getSimpleName();
      metaData.setJaccContextID(contextID);

      webApp = new WebApplication(metaData);
      webApp.setClassLoader(warLoader);
      webApp.setDeploymentUnit(unit);
      performDeploy(webApp, warURLString);
    } finally {
      thread.setContextClassLoader(appClassLoader);
    }
    return webApp;
  }
  /**
   * Ultimately, the container name should come from the <code>sessionBeanMetadata</code>. However
   * because of the current behaviour where the container on its start sets the containername in the
   * metadata, its not possible to get this information even before the container is started.
   *
   * <p>Hence let's for the time being create the container name from all the information that we
   * have in the <code>unit</code>
   *
   * @param unit The deployment unit
   * @param sessionBeanMetadata Session bean metadata
   * @return Returns the container name for the bean corresponding to the <code>sessionBeanMetadata
   *     </code> in the <code>unit</code>
   * @throws MalformedObjectNameException
   */
  private String getContainerName(DeploymentUnit unit, JBossSessionBeanMetaData sessionBeanMetadata)
      throws MalformedObjectNameException {
    // TODO the base ejb3 jmx object name comes from Ejb3Module.BASE_EJB3_JMX_NAME, but
    // we don't need any reference to ejb3-core. Right now just hard code here, we need
    // a better way/place for this later
    StringBuilder containerName = new StringBuilder("jboss.j2ee:service=EJB3" + ",");

    // Get the top level unit for this unit (ex: the top level might be an ear and this unit might
    // be the jar
    // in that ear
    DeploymentUnit toplevelUnit = unit.getTopLevel();
    if (toplevelUnit != null) {
      // if top level is an ear, then create the name with the ear reference
      if (isEar(toplevelUnit)) {
        containerName.append("ear=");
        containerName.append(toplevelUnit.getSimpleName());
        containerName.append(",");
      }
    }
    // now work on the passed unit, to get the jar name
    if (unit.getSimpleName() == null) {
      containerName.append("*");
    } else {
      containerName.append("jar=");
      containerName.append(unit.getSimpleName());
    }
    // now the ejbname
    containerName.append(",name=");
    containerName.append(sessionBeanMetadata.getEjbName());

    if (logger.isTraceEnabled()) {
      logger.trace(
          "Container name generated for ejb = "
              + sessionBeanMetadata.getEjbName()
              + " in unit "
              + unit
              + " is "
              + containerName);
    }
    ObjectName containerJMXName = new ObjectName(containerName.toString());
    return containerJMXName.getCanonicalName();
  }
 private void linkServiceRefs(
     DeploymentUnit unit, ServiceReferencesMetaData serviceRefs, Context envCtx)
     throws NamingException {
   if (unit instanceof VFSDeploymentUnit) {
     VFSDeploymentUnit vfsUnit = (VFSDeploymentUnit) unit;
     ClassLoader loader = unit.getClassLoader();
     UnifiedVirtualFile vfsRoot = new VirtualFileAdaptor(vfsUnit.getRoot());
     for (ServiceReferenceMetaData sref : serviceRefs) {
       String refName = sref.getServiceRefName();
       new ServiceReferenceHandler().bindServiceRef(envCtx, refName, vfsRoot, loader, sref);
     }
   }
 }
 /**
  * Returns true if this <code>unit</code> represents an .ear deployment
  *
  * @param unit
  * @return
  */
 private boolean isEar(DeploymentUnit unit) {
   return unit.getSimpleName().endsWith(".ear")
       || unit.getAttachment(JBossAppMetaData.class) != null;
 }
 protected static void removeTestComponent(DeploymentUnit unit, TestComponentMetaData test) {
   unit.removeComponent(test.name);
 }
 protected static void addTestComponent(DeploymentUnit unit, TestComponentMetaData test) {
   DeploymentUnit component = unit.addComponent(test.name);
   component.addAttachment(TestComponentMetaData.class, test);
 }
  @Override
  protected void internalDeploy(DeploymentUnit unit) throws DeploymentException {
    JBossEnterpriseBeanMetaData beanMetaData =
        unit.getAttachment(JBossEnterpriseBeanMetaData.class);
    if (beanMetaData == null) return;

    if (!beanMetaData.isSession()) return;

    JBossSessionBeanMetaData sessionBeanMetaData = (JBossSessionBeanMetaData) beanMetaData;

    String appName = getApplicationName(unit);
    String moduleName = getModuleName(unit);
    String componentName = getComponentName(unit);

    String javaCompName = "jboss.naming:";
    if (appName != null) javaCompName += "application=" + appName + ",";
    javaCompName += "module=" + moduleName + ",component=" + componentName;

    String sessionBeanTypeName = "jboss.ejb3:";
    if (appName != null) sessionBeanTypeName += "application=" + appName + ",";
    sessionBeanTypeName +=
        "module="
            + moduleName
            + ",component="
            + componentName
            + ",service="
            + SessionBeanTypeWrapper.class.getSimpleName();
    {
      BeanMetaDataBuilder builder =
          BeanMetaDataBuilderFactory.createBuilder(
              sessionBeanTypeName, SessionBeanTypeWrapper.class.getName());
      builder.addConstructorParameter(
          JBossSessionBeanMetaData.class.getName(), sessionBeanMetaData);
      builder.addConstructorParameter(ClassLoader.class.getName(), unit.getClassLoader());
      builder.addConstructorParameter(
          JavaEEComponent.class.getName(), builder.createInject(javaCompName));

      unit.getParent().addAttachment(sessionBeanTypeName, builder.getBeanMetaData());
    }

    String beanInstanceName = "jboss.ejb3:";
    if (appName != null) beanInstanceName += "application=" + appName + ",";
    beanInstanceName +=
        "module="
            + moduleName
            + ",component="
            + componentName
            + ",service="
            + EJBBinder.class.getSimpleName();
    BeanMetaDataBuilder builder =
        BeanMetaDataBuilderFactory.createBuilder(beanInstanceName, EJBBinder.class.getName());
    builder.addConstructorParameter(
        SessionBeanType.class.getName(), builder.createInject(sessionBeanTypeName));
    builder.addPropertyMetaData(
        "globalContext", builder.createInject("NameSpaces", "globalContext"));
    builder.addPropertyMetaData("proxyFactory", sessionBeanMetaData.isStateless() ? lazy : legacy);
    builder.setStart("bind");
    builder.setStop("unbind");

    for (DependencyBuilder db : builders) db.buildDependency(unit, builder);

    unit.getParent().addAttachment(beanInstanceName, builder.getBeanMetaData());
  }
 public static String getBeanName(DeploymentUnit unit, String serviceName) {
   return PREFIX + unit.getSimpleName() + "." + serviceName;
 }
 /**
  * @see
  *     org.jboss.ejb3.deployers.metadata.processor.JBossMetaDataProcessorFactory#create(org.jboss.deployers.structure.spi.DeploymentUnit)
  * @throws NullPointerException If <code>deploymentUnit</code> is null
  */
 @Override
 public JBossMetaDataProcessor<JBossMetaData> create(DeploymentUnit deploymentUnit) {
   return new ImplicitNoInterfaceViewProcessor(deploymentUnit.getClassLoader());
 }
  /**
   * Creates a {@link NoInterfaceViewJNDIBinderFacade} MC bean for the no-interface view represented
   * by the <code>sessionBeanMetaData</code>. The {@link NoInterfaceViewJNDIBinderFacade} is created
   * only if the bean is eligible for a no-interface view as defined by the EJB3.1 spec
   *
   * <p>The {@link NoInterfaceViewJNDIBinderFacade}, thus created, will be dependent on the {@link
   * ControllerState#DESCRIBED} state of the container (endpoint) MC bean. This way, we ensure that
   * this {@link NoInterfaceViewJNDIBinderFacade} will be deployed only after the corresponding
   * container MC bean moves to {@link ControllerState#DESCRIBED} state.
   *
   * @param unit Deployment unit
   * @param sessionBeanMetaData Session bean metadata
   * @throws DeploymentException If any exceptions are encountered during processing of the
   *     deployment unit
   */
  private void deploy(DeploymentUnit unit, JBossSessionBean31MetaData sessionBeanMetaData)
      throws DeploymentException {
    try {
      if (!sessionBeanMetaData.isNoInterfaceBean()) {
        if (logger.isTraceEnabled()) {
          logger.trace(
              "Bean class "
                  + sessionBeanMetaData.getEjbClass()
                  + " is not eligible for no-interface view");
        }
        return;
      }
      Class<?> beanClass =
          Class.forName(sessionBeanMetaData.getEjbClass(), false, unit.getClassLoader());

      String containerMCBeanName = sessionBeanMetaData.getContainerName();
      if (logger.isTraceEnabled()) {
        logger.trace(
            "Container name for bean "
                + sessionBeanMetaData.getEjbName()
                + " in unit "
                + unit
                + " is "
                + containerMCBeanName);
      }
      if (containerMCBeanName == null) {
        // The container name is set in the metadata only after the creation of the container
        // However, this deployer does not have an dependency on the creation of a container,
        // so getting the container name from the bean metadata won't work. Need to do a
        // different/better way
        // String containerMCBeanName = sessionBeanMetaData.getContainerName();
        containerMCBeanName = getContainerName(unit, sessionBeanMetaData);
      }

      // Create the NoInterfaceViewJNDIBinder (MC bean) and add a dependency on the DESCRIBED
      // state of the container (endpoint) MC bean
      NoInterfaceViewJNDIBinderFacade noInterfaceViewJNDIBinderFacade =
          new NoInterfaceViewJNDIBinderFacade(new InitialContext(), beanClass, sessionBeanMetaData);
      String noInterfaceViewMCBeanName = unit.getName() + "$" + sessionBeanMetaData.getEjbName();
      BeanMetaDataBuilder builder =
          BeanMetaDataBuilder.createBuilder(
              noInterfaceViewMCBeanName, noInterfaceViewJNDIBinderFacade.getClass().getName());
      builder.setConstructorValue(noInterfaceViewJNDIBinderFacade);

      // add dependency
      AbstractInjectionValueMetaData injectMetaData =
          new AbstractInjectionValueMetaData(containerMCBeanName);
      // EJBTHREE-2166 - Depending on DESCRIBED state and then pushing to INSTALLED
      // through MC API, won't work. So for now, just depend on INSTALLED state.
      // injectMetaData.setDependentState(ControllerState.DESCRIBED);
      injectMetaData.setDependentState(ControllerState.INSTALLED);
      injectMetaData.setFromContext(FromContext.CONTEXT);

      // Too bad we have to know the field name. Need to do more research on MC to see if we can
      // add property metadata based on type instead of field name.
      builder.addPropertyMetaData("endpointContext", injectMetaData);

      // Add this as an attachment
      unit.addAttachment(
          BeanMetaData.class + ":" + noInterfaceViewMCBeanName, builder.getBeanMetaData());

      logger.debug(
          "No-interface JNDI binder for container "
              + containerMCBeanName
              + " has been created and added to the deployment unit "
              + unit);

    } catch (Throwable t) {
      DeploymentException.rethrowAsDeploymentException(
          "Could not create no-interface view for "
              + sessionBeanMetaData.getEjbClass()
              + " in unit "
              + unit.getName(),
          t);
    }
  }