@Override
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {

    // Check if we already have an OSGi deployment
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    Deployment deployment = OSGiDeploymentAttachment.getDeployment(deploymentUnit);

    ServiceRegistry serviceRegistry = phaseContext.getServiceRegistry();
    String location =
        DeploymentHolderService.getLocation(serviceRegistry, deploymentUnit.getName());
    VirtualFile virtualFile = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT).getRoot();

    // Check for attached BundleInfo
    BundleInfo info = BundleInfoAttachment.getBundleInfo(deploymentUnit);
    if (deployment == null && info != null) {
      deployment = DeploymentFactory.createDeployment(info);
      deployment.addAttachment(BundleInfo.class, info);
      OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
    }

    // Check for attached OSGiMetaData
    OSGiMetaData metadata = OSGiMetaDataAttachment.getOSGiMetaData(deploymentUnit);
    if (deployment == null && metadata != null) {
      String symbolicName = metadata.getBundleSymbolicName();
      Version version = metadata.getBundleVersion();
      deployment =
          DeploymentFactory.createDeployment(
              AbstractVFS.adapt(virtualFile), location, symbolicName, version);
      deployment.addAttachment(OSGiMetaData.class, metadata);
      OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
    }

    // Check for attached XModule
    XModule resModule = XModuleAttachment.getXModuleAttachment(deploymentUnit);
    if (deployment == null && resModule != null) {
      String symbolicName = resModule.getName();
      Version version = resModule.getVersion();
      deployment =
          DeploymentFactory.createDeployment(
              AbstractVFS.adapt(virtualFile), location, symbolicName, version);
      deployment.addAttachment(XModule.class, resModule);
      OSGiDeploymentAttachment.attachDeployment(deploymentUnit, deployment);
    }

    // Create the {@link OSGiDeploymentService}
    if (deployment != null) {

      // Prevent garbage collection of the MountHandle which will close the file
      MountHandle mount =
          deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT).getMountHandle();
      deployment.addAttachment(MountHandle.class, mount);

      // Mark the bundle to start automatically
      deployment.setAutoStart(true);

      OSGiDeploymentService.addService(phaseContext);
    }
  }
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final EEModuleDescription eeModuleDescription =
        deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
    final CompositeIndex index =
        deploymentUnit.getAttachment(
            org.jboss.as.server.deployment.Attachments.COMPOSITE_ANNOTATION_INDEX);
    final EEApplicationClasses applicationClasses =
        deploymentUnit.getAttachment(Attachments.EE_APPLICATION_CLASSES_DESCRIPTION);

    // @PersistenceContext
    List<AnnotationInstance> persistenceContexts =
        index.getAnnotations(PERSISTENCE_CONTEXT_ANNOTATION_NAME);
    // create binding and injection configurations out of the @PersistenceContext annotations
    this.processPersistenceAnnotations(
        deploymentUnit, eeModuleDescription, persistenceContexts, applicationClasses);

    // @PersistenceUnit
    List<AnnotationInstance> persistenceUnits =
        index.getAnnotations(PERSISTENCE_UNIT_ANNOTATION_NAME);
    // create binding and injection configurations out of the @PersistenceUnit annotaitons
    this.processPersistenceAnnotations(
        deploymentUnit, eeModuleDescription, persistenceUnits, applicationClasses);

    // if we found any @PersistenceContext or @PersistenceUnit annotations then mark this as a JPA
    // deployment
    if (!persistenceContexts.isEmpty() || !persistenceUnits.isEmpty()) {
      JPADeploymentMarker.mark(deploymentUnit);
    }
  }
 @Before
 public void init() {
   when(phaseContext.getDeploymentUnit()).thenReturn(deploymentUnit);
   when(deploymentUnit.getAttachment(Attachments.DEPLOYMENT_TYPE)).thenReturn(DeploymentType.WAR);
   WarMetaData metadata = mock(WarMetaData.class);
   when(deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY)).thenReturn(metadata);
 }
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit du = phaseContext.getDeploymentUnit();

    if (GateInConfiguration.isGateInArchive(du)) {
      log.info("Module is on GateIn Extension modules list");
      final GateInConfiguration config = du.getAttachment(GateInConfigurationKey.KEY);

      final ServiceName initSvcName =
          GateInExtension.deploymentUnitName(config.getGateInEarModule(), "gatein", "init");
      final ServiceTarget target = phaseContext.getServiceTarget();

      if (du.getAttachment(GateInEarKey.KEY) != null) {
        // Install InitService with dependency on all the deployment modules reaching POST_MODULE
        // TODO: we are starting up InitService before child modules (jboss.deployment.subunit.*)
        // have gone through POST_MODULE
        final ServiceBuilder<InitService> builder =
            target
                .addService(initSvcName, new InitService(config))
                .addDependency(
                    GateInExtension.deploymentUnitName(
                        config.getGateInEarModule(), Phase.POST_MODULE));

        for (ModuleIdentifier module : config.getGateInExtModules()) {
          builder.addDependency(GateInExtension.deploymentUnitName(module, Phase.POST_MODULE));
        }
        builder.install();
        log.info("Installed " + initSvcName);
      }
      // all gatein deployment modules use InitService as barrier on POST_MODULE to ensure
      // they are all available on the classpath when init time resource loading takes place
      phaseContext.addToAttachmentList(Attachments.NEXT_PHASE_DEPS, initSvcName);
      log.info("Added NEXT_PHASE_DEP on " + initSvcName);
    }
  }
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();

    ClojureMetaData metaData = deploymentUnit.getAttachment(ClojureMetaData.ATTACHMENT_KEY);

    if (metaData == null) {
      return;
    }

    Timer t = new Timer("reading full app config");
    ResourceRoot resourceRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    File root;
    File descriptor = deploymentUnit.getAttachment(ClojureMetaData.DESCRIPTOR_FILE);
    try {
      root = resourceRoot.getRoot().getPhysicalFile();
      metaData.setConfig(ApplicationBootstrapUtils.readFullAppConfig(descriptor, root));
      deploymentUnit.putAttachment(
          ClojureMetaData.FULL_APP_CONFIG,
          ApplicationBootstrapUtils.readFullAppConfigAsString(descriptor, root));
      deploymentUnit.putAttachment(
          ClojureMetaData.LEIN_PROJECT,
          ApplicationBootstrapUtils.readProjectAsString(descriptor, root));
    } catch (Exception e) {
      throw new DeploymentUnitProcessingException(e);
    }
    t.done();
  }
  @Override
  protected boolean canHandle(DeploymentUnit deploymentUnit) {
    if (!DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)) {
      return false;
    }

    final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
    if (warMetaData == null) {
      return false; // Nothing we can do without WarMetaData
    }
    final ResourceRoot deploymentRoot =
        deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.DEPLOYMENT_ROOT);
    if (deploymentRoot == null) {
      return false; // We don't have a root to work with
    }

    final DeploymentUnit parent = deploymentUnit.getParent();
    if (parent == null || !DeploymentTypeMarker.isType(DeploymentType.EAR, parent)) {
      return false; // Only care if this war is nested in an EAR
    }

    final EarMetaData earMetaData = parent.getAttachment(Attachments.EAR_METADATA);
    if (earMetaData == null) {
      return false; // Nothing to see here
    }

    return true;
  }
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    if (!DeploymentTypeMarker.isType(DeploymentType.EAR, deploymentUnit)) {
      return;
    }
    final ResourceRoot deploymentRoot =
        deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.DEPLOYMENT_ROOT);
    final VirtualFile deploymentFile = deploymentRoot.getRoot();
    final VirtualFile applicationXmlFile = deploymentFile.getChild(JBOSS_APP_XML);
    if (!applicationXmlFile.exists()) {
      return;
    }

    InputStream inputStream = null;
    try {
      inputStream = applicationXmlFile.openStream();
      final XMLInputFactory inputFactory = XMLInputFactory.newInstance();
      inputFactory.setXMLResolver(NoopXmlResolver.create());
      XMLStreamReader xmlReader = inputFactory.createXMLStreamReader(inputStream);
      final JBossAppMetaData appMetaData = JBossAppMetaDataParser.parse(xmlReader);
      if (appMetaData != null) {
        final EarMetaData earMetaData = deploymentUnit.getAttachment(Attachments.EAR_METADATA);
        if (earMetaData != null) {
          JBossAppMetaDataMerger.merge(appMetaData, null, earMetaData);
        }
        deploymentUnit.putAttachment(Attachments.JBOSS_APP_METADATA, appMetaData);
      }
    } catch (Exception e) {
      throw new DeploymentUnitProcessingException("Failed to parse " + applicationXmlFile, e);
    } finally {
      VFSUtils.safeClose(inputStream);
    }
  }
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();

    if (!KeycloakAdapterConfigService.getInstance().isSecureDeployment(deploymentUnit)) {
      WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
      if (warMetaData == null) {
        return;
      }
      JBossWebMetaData webMetaData = warMetaData.getMergedJBossWebMetaData();
      if (webMetaData == null) {
        return;
      }
      LoginConfigMetaData loginConfig = webMetaData.getLoginConfig();
      if (loginConfig == null) return;
      if (loginConfig.getAuthMethod() == null) return;
      if (!loginConfig.getAuthMethod().equals("KEYCLOAK")) return;
    }

    final ModuleSpecification moduleSpecification =
        deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION);
    final ModuleLoader moduleLoader = Module.getBootModuleLoader();
    addCommonModules(moduleSpecification, moduleLoader);
    addPlatformSpecificModules(moduleSpecification, moduleLoader);
  }
示例#9
0
 private static void processWSFeatures(
     final DeploymentUnit unit,
     final Set<ResourceInjectionTargetMetaData> injectionTargets,
     final UnifiedServiceRefMetaData serviceRefUMDM)
     throws DeploymentUnitProcessingException {
   if (injectionTargets == null || injectionTargets.size() == 0) return;
   if (injectionTargets.size() > 1) {
     // TODO: We should validate all the injection targets whether they're compatible.
     // This means all the injection targets must be assignable or equivalent.
     // If there are @Addressing, @RespectBinding or @MTOM annotations present on injection
     // targets,
     // these annotations must be equivalent for all the injection targets.
   }
   final Module module = unit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE);
   final DeploymentReflectionIndex deploymentReflectionIndex =
       unit.getAttachment(org.jboss.as.server.deployment.Attachments.REFLECTION_INDEX);
   final ResourceInjectionTargetMetaData injectionTarget = injectionTargets.iterator().next();
   final String injectionTargetClassName = injectionTarget.getInjectionTargetClass();
   final String injectionTargetName = injectionTarget.getInjectionTargetName();
   final AccessibleObject fieldOrMethod =
       getInjectionTarget(
           injectionTargetClassName,
           injectionTargetName,
           module.getClassLoader(),
           deploymentReflectionIndex);
   processAnnotatedElement(fieldOrMethod, serviceRefUMDM);
 }
 @Override
 protected void processDeployment(
     final DeploymentPhaseContext phaseContext,
     final DeploymentUnit deploymentUnit,
     final ResourceRoot root)
     throws DeploymentUnitProcessingException {
   final List<DeploymentUnit> subDeployments = getSubDeployments(deploymentUnit);
   final String loggingProfile = findLoggingProfile(root);
   if (loggingProfile != null) {
     // Get the profile logging context
     final LoggingProfileContextSelector loggingProfileContext =
         LoggingProfileContextSelector.getInstance();
     if (loggingProfileContext.exists(loggingProfile)) {
       // Get the module
       final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
       final LogContext logContext = loggingProfileContext.get(loggingProfile);
       LoggingLogger.ROOT_LOGGER.tracef(
           "Registering log context '%s' on '%s' for profile '%s'",
           logContext, root, loggingProfile);
       registerLogContext(deploymentUnit, module, logContext);
       // Process sub-deployments
       for (DeploymentUnit subDeployment : subDeployments) {
         // A sub-deployment must have a module to process
         if (subDeployment.hasAttachment(Attachments.MODULE)) {
           // Set the result to true if a logging profile was found
           if (subDeployment.hasAttachment(Attachments.DEPLOYMENT_ROOT)) {
             processDeployment(
                 phaseContext,
                 subDeployment,
                 subDeployment.getAttachment(Attachments.DEPLOYMENT_ROOT));
           }
           if (!hasRegisteredLogContext(subDeployment)) {
             final Module subDeploymentModule = subDeployment.getAttachment(Attachments.MODULE);
             LoggingLogger.ROOT_LOGGER.tracef(
                 "Registering log context '%s' on '%s' for profile '%s'",
                 logContext,
                 subDeployment.getAttachment(Attachments.DEPLOYMENT_ROOT),
                 loggingProfile);
             registerLogContext(subDeployment, subDeploymentModule, logContext);
           }
         }
       }
     } else {
       LoggingLogger.ROOT_LOGGER.loggingProfileNotFound(loggingProfile, root);
     }
   } else {
     // No logging profile found, but the sub-deployments should be checked for logging profiles
     for (DeploymentUnit subDeployment : subDeployments) {
       // A sub-deployment must have a root resource and a module to process
       if (subDeployment.hasAttachment(Attachments.MODULE)
           && subDeployment.hasAttachment(Attachments.DEPLOYMENT_ROOT)) {
         processDeployment(
             phaseContext,
             subDeployment,
             subDeployment.getAttachment(Attachments.DEPLOYMENT_ROOT));
       }
     }
   }
 }
  /**
   * Check the deployment annotation index for all classes with the @ManagedBean annotation. For
   * each class with the annotation, collect all the required information to create a managed bean
   * instance, and attach it to the context.
   *
   * @param phaseContext the deployment unit context
   * @throws DeploymentUnitProcessingException
   */
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final EEModuleDescription moduleDescription =
        deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
    final String applicationName = moduleDescription.getAppName();
    final CompositeIndex compositeIndex =
        deploymentUnit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX);
    if (compositeIndex == null) {
      return;
    }
    final List<AnnotationInstance> instances =
        compositeIndex.getAnnotations(MANAGED_BEAN_ANNOTATION_NAME);
    if (instances == null || instances.isEmpty()) {
      return;
    }

    for (AnnotationInstance instance : instances) {
      AnnotationTarget target = instance.target();
      if (!(target instanceof ClassInfo)) {
        throw new DeploymentUnitProcessingException(
            "The ManagedBean annotation is only allowed at the class level: " + target);
      }
      final ClassInfo classInfo = (ClassInfo) target;
      final String beanClassName = classInfo.name().toString();

      // Get the managed bean name from the annotation
      final AnnotationValue nameValue = instance.value();
      final String beanName =
          nameValue == null || nameValue.asString().isEmpty()
              ? beanClassName
              : nameValue.asString();
      final ManagedBeanComponentDescription componentDescription =
          new ManagedBeanComponentDescription(
              beanName, beanClassName, moduleDescription.getModuleName(), applicationName);
      final ServiceName baseName =
          deploymentUnit.getServiceName().append("component").append(beanName);

      // Add the view
      componentDescription.getViewClassNames().add(beanClassName);

      // Bind the view to its two JNDI locations
      // TODO - this should be a bit more elegant
      final BindingDescription moduleBinding = new BindingDescription();
      moduleBinding.setAbsoluteBinding(true);
      moduleBinding.setBindingName("java:module/" + beanName);
      moduleBinding.setBindingType(beanClassName);
      moduleBinding.setReferenceSourceDescription(
          new ServiceBindingSourceDescription(baseName.append("VIEW").append(beanClassName)));
      componentDescription.getBindings().add(moduleBinding);
      final BindingDescription appBinding = new BindingDescription();
      appBinding.setAbsoluteBinding(true);
      appBinding.setBindingName("java:app/" + moduleDescription.getModuleName() + "/" + beanName);
      appBinding.setBindingType(beanClassName);
      appBinding.setReferenceSourceDescription(
          new ServiceBindingSourceDescription(baseName.append("VIEW").append(beanClassName)));
      componentDescription.getBindings().add(appBinding);
      moduleDescription.addComponent(componentDescription);
    }
  }
  @Override
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final EEModuleDescription eeModuleDescription =
        deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
    final Module module =
        deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE);

    if (eeModuleDescription == null) {
      return;
    }

    final Collection<ComponentDescription> componentConfigurations =
        eeModuleDescription.getComponentDescriptions();

    final DeploymentReflectionIndex deploymentReflectionIndex =
        deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.REFLECTION_INDEX);
    final EEApplicationClasses applicationClasses =
        deploymentUnit.getAttachment(Attachments.EE_APPLICATION_CLASSES_DESCRIPTION);

    for (ComponentDescription componentConfiguration : componentConfigurations) {
      if (componentConfiguration instanceof SessionBeanComponentDescription) {
        try {
          processComponentConfig(
              deploymentUnit,
              applicationClasses,
              module,
              deploymentReflectionIndex,
              (SessionBeanComponentDescription) componentConfiguration);
        } catch (Exception e) {
          throw MESSAGES.failToMergeData(componentConfiguration.getComponentName(), e);
        }
      }
    }
    if (appclient) {
      for (ComponentDescription componentDescription :
          deploymentUnit.getAttachmentList(Attachments.ADDITIONAL_RESOLVABLE_COMPONENTS)) {
        if (componentDescription instanceof SessionBeanComponentDescription) {
          try {
            processComponentConfig(
                deploymentUnit,
                applicationClasses,
                module,
                deploymentReflectionIndex,
                (SessionBeanComponentDescription) componentDescription);
          } catch (Exception e) {
            throw MESSAGES.failToMergeData(componentDescription.getComponentName(), e);
          }
        }
      }
    }
  }
示例#13
0
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
    if (warMetaData == null) {
      return; // Nothing we can do without WarMetaData
    }
    final ResourceRoot deploymentRoot =
        deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.DEPLOYMENT_ROOT);
    if (deploymentRoot == null) {
      return; // We don't have a root to work with
    }

    final DeploymentUnit parent = deploymentUnit.getParent();
    if (parent == null || !DeploymentTypeMarker.isType(DeploymentType.EAR, parent)) {
      return; // Only care if this war is nested in an EAR
    }

    final EarMetaData earMetaData = parent.getAttachment(Attachments.EAR_METADATA);
    if (earMetaData == null) {
      return; // Nothing to see here
    }

    final ModulesMetaData modulesMetaData = earMetaData.getModules();
    if (modulesMetaData != null)
      for (ModuleMetaData moduleMetaData : modulesMetaData) {
        if (Web.equals(moduleMetaData.getType())
            && moduleMetaData.getFileName().equals(deploymentRoot.getRootName())) {
          String contextRoot =
              WebModuleMetaData.class.cast(moduleMetaData.getValue()).getContextRoot();

          if (contextRoot == null
              && (warMetaData.getJbossWebMetaData() == null
                  || warMetaData.getJbossWebMetaData().getContextRoot() == null)) {
            contextRoot =
                "/"
                    + parent.getName().substring(0, parent.getName().length() - 4)
                    + "/"
                    + deploymentUnit.getName().substring(0, deploymentUnit.getName().length() - 4);
          }

          if (contextRoot != null) {
            JBossWebMetaData jBossWebMetaData = warMetaData.getJbossWebMetaData();
            if (jBossWebMetaData == null) {
              jBossWebMetaData = new JBoss70WebMetaData();
              warMetaData.setJbossWebMetaData(jBossWebMetaData);
            }
            jBossWebMetaData.setContextRoot(contextRoot);
          }
          return;
        }
      }
  }
示例#14
0
  /** {@inheritDoc} */
  @Override
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
    final ServicesAttachment servicesAttachment =
        deploymentUnit.getAttachment(Attachments.SERVICES);
    if (module != null && servicesAttachment != null) {
      final ModuleClassLoader classLoader = module.getClassLoader();
      final List<String> driverNames =
          servicesAttachment.getServiceImplementations(Driver.class.getName());
      for (String driverClassName : driverNames) {
        try {
          final Class<? extends Driver> driverClass =
              classLoader.loadClass(driverClassName).asSubclass(Driver.class);
          final Constructor<? extends Driver> constructor = driverClass.getConstructor();
          final Driver driver = constructor.newInstance();
          final int majorVersion = driver.getMajorVersion();
          final int minorVersion = driver.getMinorVersion();
          final boolean compliant = driver.jdbcCompliant();
          if (compliant) {
            log.infof(
                "Deploying JDBC-compliant driver %s (version %d.%d)",
                driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
          } else {
            log.infof(
                "Deploying non-JDBC-compliant driver %s (version %d.%d)",
                driverClass, Integer.valueOf(majorVersion), Integer.valueOf(minorVersion));
          }
          String driverName = deploymentUnit.getName();
          InstalledDriver driverMetadata =
              new InstalledDriver(
                  driverName, driverClass.getName(), null, majorVersion, minorVersion, compliant);
          DriverService driverService = new DriverService(driverMetadata, driver);
          phaseContext
              .getServiceTarget()
              .addService(
                  ServiceName.JBOSS.append("jdbc-driver", driverName.replaceAll(".", "_")),
                  driverService)
              .addDependency(
                  ConnectorServices.JDBC_DRIVER_REGISTRY_SERVICE,
                  DriverRegistry.class,
                  driverService.getDriverRegistryServiceInjector())
              .setInitialMode(Mode.ACTIVE)
              .install();

        } catch (Exception e) {
          log.warnf("Unable to instantiate driver class \"%s\": %s", driverClassName, e);
        }
      }
    }
  }
 private Set<ViewDescription> getViews(final DeploymentPhaseContext phaseContext) {
   final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
   final EEApplicationDescription applicationDescription =
       deploymentUnit.getAttachment(EE_APPLICATION_DESCRIPTION);
   final ResourceRoot deploymentRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
   final Set<ViewDescription> componentsForViewName;
   if (beanName != null) {
     componentsForViewName =
         applicationDescription.getComponents(beanName, typeName, deploymentRoot.getRoot());
   } else {
     componentsForViewName = applicationDescription.getComponentsForViewName(typeName);
   }
   return componentsForViewName;
 }
  public void deploy(final DeploymentPhaseContext phaseContext)
      throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();

    final Map<Class<? extends Annotation>, Set<Class<?>>> instances =
        new HashMap<Class<? extends Annotation>, Set<Class<?>>>();

    final CompositeIndex compositeIndex =
        deploymentUnit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX);
    if (compositeIndex == null) {
      return; // Can not continue without index
    }

    final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
    if (module == null) {
      return; // Can not continue without module
    }
    final ClassLoader classLoader = module.getClassLoader();

    for (FacesAnnotation annotation : FacesAnnotation.values()) {
      final List<AnnotationInstance> annotationInstances =
          compositeIndex.getAnnotations(annotation.indexName);
      if (annotationInstances == null || annotationInstances.isEmpty()) {
        continue;
      }
      final Set<Class<?>> discoveredClasses = new HashSet<Class<?>>();
      instances.put(annotation.annotationClass, discoveredClasses);
      for (AnnotationInstance annotationInstance : annotationInstances) {
        final AnnotationTarget target = annotationInstance.target();
        if (target instanceof ClassInfo) {
          final DotName className = ClassInfo.class.cast(target).name();
          final Class<?> annotatedClass;
          try {
            annotatedClass = classLoader.loadClass(className.toString());
          } catch (ClassNotFoundException e) {
            throw new DeploymentUnitProcessingException(
                JSFMessages.MESSAGES.classLoadingFailed(className));
          }
          discoveredClasses.add(annotatedClass);
        } else {
          throw new DeploymentUnitProcessingException(
              JSFMessages.MESSAGES.invalidAnnotationLocation(annotation, target));
        }
      }
    }
    deploymentUnit.addToAttachmentList(
        ServletContextAttribute.ATTACHMENT_KEY,
        new ServletContextAttribute(FACES_ANNOTATIONS_SC_ATTR, instances));
  }
 public void deploy(final DeploymentPhaseContext phaseContext)
     throws DeploymentUnitProcessingException {
   final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
   final String deploymentUnitName = deploymentUnit.getName();
   final String moduleName;
   if (deploymentUnitName.endsWith(".war")
       || deploymentUnitName.endsWith(".wab")
       || deploymentUnitName.endsWith(".jar")
       || deploymentUnitName.endsWith(".ear")
       || deploymentUnitName.endsWith(".rar")) {
     moduleName = deploymentUnitName.substring(0, deploymentUnitName.length() - 4);
   } else {
     moduleName = deploymentUnitName;
   }
   final String appName;
   final String earApplicationName =
       deploymentUnit.getAttachment(Attachments.EAR_APPLICATION_NAME);
   // the ear application name takes into account the name set in application.xml
   // if this is non-null this is always the one we want to use
   if (earApplicationName != null) {
     appName = earApplicationName;
   } else {
     // an appname of null means use the module name
     appName = null;
   }
   deploymentUnit.putAttachment(
       Attachments.EE_MODULE_DESCRIPTION,
       new EEModuleDescription(appName, moduleName, earApplicationName, appClient));
 }
示例#18
0
  @Override
  public Set<String> getUpdatedResources(
      final String deploymentName, final Map<String, Long> updatedResources) {
    final ModuleIdentifier moduleId = getModuleIdentifier(deploymentName);
    final ModuleClassLoader loader = loadersByModuleIdentifier.get(moduleId);
    if (loader == null) {
      return Collections.emptySet();
    }

    final DeploymentUnit deploymentUnit =
        (DeploymentUnit)
            CurrentServiceRegistry.getServiceRegistry()
                .getRequiredService(Services.deploymentUnitName(deploymentName))
                .getValue();
    final ResourceRoot root = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);

    final Set<String> resources = new HashSet<String>();
    for (final Map.Entry<String, Long> entry : updatedResources.entrySet()) {
      final VirtualFile file = root.getRoot().getChild(entry.getKey());
      if (file.exists()) {
        long last = file.getLastModified();
        if (entry.getValue() > last) {
          resources.add(entry.getKey());
        }
      }
    }
    return resources;
  }
示例#19
0
  @Override
  public void updateResource(
      final String archiveName, final Map<String, byte[]> replacedResources) {
    final ModuleIdentifier moduleId = getModuleIdentifier(archiveName);
    final ModuleClassLoader loader = loadersByModuleIdentifier.get(moduleId);
    if (loader == null) {
      return;
    }

    final DeploymentUnit deploymentUnit =
        (DeploymentUnit)
            CurrentServiceRegistry.getServiceRegistry()
                .getRequiredService(Services.deploymentUnitName(archiveName))
                .getValue();
    final ResourceRoot root = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);

    for (final Map.Entry<String, byte[]> entry : replacedResources.entrySet()) {
      final VirtualFile file = root.getRoot().getChild(entry.getKey());
      try {
        final FileOutputStream stream = new FileOutputStream(file.getPhysicalFile(), false);
        try {
          stream.write(entry.getValue());
        } finally {
          stream.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
  protected VirtualFile getFile(DeploymentUnit unit)
      throws DeploymentUnitProcessingException, IOException {
    List<VirtualFile> matches = new ArrayList<VirtualFile>();

    ResourceRoot resourceRoot = unit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    if (resourceRoot == null) {
      return null;
    }
    VirtualFile root = resourceRoot.getRoot();

    if (this.knobFilter.accepts(root)) {
      return root;
    }

    matches = root.getChildren(this.knobFilter);

    if (matches.size() > 1) {
      throw new DeploymentUnitProcessingException("Multiple Immutant descriptors found in " + root);
    }

    VirtualFile file = null;
    if (matches.size() == 1) {
      file = matches.get(0);
    }

    return file;
  }
示例#21
0
 /**
  * Gets list of JAXWS POJOs meta data.
  *
  * @param unit deployment unit
  * @return list of JAXWS POJOs meta data
  */
 public static List<POJOEndpoint> getJaxwsPojos(final DeploymentUnit unit) {
   final JAXWSDeployment jaxwsDeployment =
       unit.getAttachment(WSAttachmentKeys.JAXWS_ENDPOINTS_KEY);
   return jaxwsDeployment != null
       ? jaxwsDeployment.getPojoEndpoints()
       : Collections.<POJOEndpoint>emptyList();
 }
示例#22
0
  public static String pathNameOfDeployment(
      final DeploymentUnit deploymentUnit, final JBossWebMetaData metaData) {
    String pathName;
    if (metaData.getContextRoot() == null) {

      final EEModuleDescription description =
          deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
      if (description != null) {
        // if there is a EEModuleDescription we need to take into account that the module name
        // may have been overridden
        pathName = "/" + description.getModuleName();
      } else {
        pathName =
            "/" + deploymentUnit.getName().substring(0, deploymentUnit.getName().length() - 4);
      }
    } else {
      pathName = metaData.getContextRoot();
      if ("/".equals(pathName)) {
        pathName = "";
      } else if (pathName.length() > 0 && pathName.charAt(0) != '/') {
        pathName = "/" + pathName;
      }
    }
    return pathName;
  }
  private HashMap<String, TagLibraryInfo> createTldsInfo(
      final DeploymentUnit deploymentUnit,
      final DeploymentClassIndex classReflectionIndex,
      final ComponentRegistry components,
      final DeploymentInfo d)
      throws ClassNotFoundException {

    TldsMetaData tldsMetaData = deploymentUnit.getAttachment(TldsMetaData.ATTACHMENT_KEY);
    final HashMap<String, TagLibraryInfo> ret = new HashMap<>();
    if (tldsMetaData != null) {
      if (tldsMetaData.getTlds() != null) {
        for (Map.Entry<String, TldMetaData> tld : tldsMetaData.getTlds().entrySet()) {
          createTldInfo(tld.getKey(), tld.getValue(), ret, classReflectionIndex, components, d);
        }
      }
      List<TldMetaData> sharedTlds = tldsMetaData.getSharedTlds(deploymentUnit);
      if (sharedTlds != null) {
        for (TldMetaData metaData : sharedTlds) {

          createTldInfo(null, metaData, ret, classReflectionIndex, components, d);
        }
      }
    }

    return ret;
  }
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final EEModuleDescription moduleDescription =
        deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);

    if (moduleDescription == null) {
      return;
    }

    final ServiceTarget serviceTarget = phaseContext.getServiceTarget();
    // if this is a war we need to bind to the modules comp namespace
    if (DeploymentTypeMarker.isType(DeploymentType.WAR, deploymentUnit)
        || DeploymentTypeMarker.isType(DeploymentType.APPLICATION_CLIENT, deploymentUnit)) {
      final ServiceName moduleContextServiceName =
          ContextNames.contextServiceNameOfModule(
              moduleDescription.getApplicationName(), moduleDescription.getModuleName());
      bindServices(deploymentUnit, serviceTarget, moduleContextServiceName);
    }

    for (ComponentDescription component : moduleDescription.getComponentDescriptions()) {
      if (component.getNamingMode() == ComponentNamingMode.CREATE) {
        final ServiceName compContextServiceName =
            ContextNames.contextServiceNameOfComponent(
                moduleDescription.getApplicationName(),
                moduleDescription.getModuleName(),
                component.getComponentName());
        bindServices(deploymentUnit, serviceTarget, compContextServiceName);
      }
    }
  }
示例#25
0
 public static WSReferences getWSRefRegistry(final DeploymentUnit unit) {
   WSReferences refRegistry = unit.getAttachment(WSAttachmentKeys.WS_REFERENCES);
   if (refRegistry == null) {
     refRegistry = WSReferences.newInstance();
     unit.putAttachment(WSAttachmentKeys.WS_REFERENCES, refRegistry);
   }
   return refRegistry;
 }
示例#26
0
  /**
   * Returns required attachment value from deployment unit.
   *
   * @param <A> expected value
   * @param unit deployment unit
   * @param key attachment key
   * @return required attachment
   * @throws IllegalStateException if attachment value is null
   */
  public static <A> A getRequiredAttachment(final DeploymentUnit unit, final AttachmentKey<A> key) {
    final A value = unit.getAttachment(key);
    if (value == null) {
      throw new IllegalStateException();
    }

    return value;
  }
示例#27
0
 public static JAXWSDeployment getJaxwsDeployment(final DeploymentUnit unit) {
   JAXWSDeployment wsDeployment = unit.getAttachment(JAXWS_ENDPOINTS_KEY);
   if (wsDeployment == null) {
     wsDeployment = new JAXWSDeployment();
     unit.putAttachment(JAXWS_ENDPOINTS_KEY, wsDeployment);
   }
   return wsDeployment;
 }
示例#28
0
  @Override
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    if (!JaxrsDeploymentMarker.isJaxrsDeployment(deploymentUnit)) {
      return;
    }
    final DeploymentUnit parent =
        deploymentUnit.getParent() == null ? deploymentUnit : deploymentUnit.getParent();
    final Map<ModuleIdentifier, ResteasyDeploymentData> deploymentData;
    if (deploymentUnit.getParent() == null) {
      deploymentData =
          Collections.synchronizedMap(new HashMap<ModuleIdentifier, ResteasyDeploymentData>());
      deploymentUnit.putAttachment(
          JaxrsAttachments.ADDITIONAL_RESTEASY_DEPLOYMENT_DATA, deploymentData);
    } else {
      deploymentData = parent.getAttachment(JaxrsAttachments.ADDITIONAL_RESTEASY_DEPLOYMENT_DATA);
    }

    final ModuleIdentifier moduleIdentifier =
        deploymentUnit.getAttachment(Attachments.MODULE_IDENTIFIER);

    ResteasyDeploymentData resteasyDeploymentData = new ResteasyDeploymentData();
    final WarMetaData warMetaData = deploymentUnit.getAttachment(WarMetaData.ATTACHMENT_KEY);
    final Module module = deploymentUnit.getAttachment(Attachments.MODULE);

    try {

      if (warMetaData == null) {
        resteasyDeploymentData.setScanAll(true);
        scan(deploymentUnit, module.getClassLoader(), resteasyDeploymentData);
        deploymentData.put(moduleIdentifier, resteasyDeploymentData);
      } else {
        scanWebDeployment(
            deploymentUnit,
            warMetaData.getMergedJBossWebMetaData(),
            module.getClassLoader(),
            resteasyDeploymentData);
        scan(deploymentUnit, module.getClassLoader(), resteasyDeploymentData);
      }
      deploymentUnit.putAttachment(
          JaxrsAttachments.RESTEASY_DEPLOYMENT_DATA, resteasyDeploymentData);
    } catch (ModuleLoadException e) {
      throw new DeploymentUnitProcessingException(e);
    }
  }
  @Override
  public void deploy(DeploymentPhaseContext context) {

    DeploymentUnit unit = context.getDeploymentUnit();
    final ServiceName name = unit.getServiceName();
    EEModuleDescription moduleDescription = unit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
    if (moduleDescription == null) {
      return;
    }

    final ServiceTarget target = context.getServiceTarget();
    @SuppressWarnings("rawtypes")
    final InjectedValue<CacheFactoryBuilderRegistry> registry = new InjectedValue<>();
    Service<Void> service =
        new AbstractService<Void>() {
          @Override
          public void start(StartContext context) {
            // Install dependencies for each registered cache factory builder
            Collection<CacheFactoryBuilder<?, ?>> builders = registry.getValue().getBuilders();
            for (CacheFactoryBuilder<?, ?> builder : builders) {
              builder.installDeploymentUnitDependencies(target, name);
            }
          }
        };
    target
        .addService(name.append("cache-dependencies-installer"), service)
        .addDependency(
            CacheFactoryBuilderRegistryService.SERVICE_NAME,
            CacheFactoryBuilderRegistry.class,
            registry)
        .install();

    // Install versioned marshalling configuration
    InjectedValue<ModuleDeployment> deployment = new InjectedValue<>();
    Module module = unit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE);
    Value<ModuleLoader> moduleLoader = new ImmediateValue<>(module.getModuleLoader());
    target
        .addService(
            VersionedMarshallingConfigurationService.getServiceName(name),
            new VersionedMarshallingConfigurationService(deployment, moduleLoader))
        .addDependency(
            name.append(ModuleDeployment.SERVICE_NAME), ModuleDeployment.class, deployment)
        .setInitialMode(ServiceController.Mode.ON_DEMAND)
        .install();
  }
示例#30
0
  /**
   * Returns required attachment value from deployment unit.
   *
   * @param <A> expected value
   * @param unit deployment unit
   * @param key attachment key
   * @return required attachment
   * @throws IllegalStateException if attachment value is null
   */
  public static <A> A getRequiredAttachment(final DeploymentUnit unit, final AttachmentKey<A> key) {
    final A value = unit.getAttachment(key);
    if (value == null) {
      ASHelper.LOGGER.error("Cannot find attachment in deployment unit: " + key);
      throw new IllegalStateException();
    }

    return value;
  }