Examples with Application com.sun.enterprise.deployment.Application used on opensource projects

Example 51 with Application

use of com.sun.enterprise.deployment.Application in project Payara by payara.

the class RuntimeTimerState method getTimedObjectApplicationName.

String getTimedObjectApplicationName() {
    EjbDescriptor ejbDesc = container_.getEjbDescriptor();
    Application app = ejbDesc.getApplication();
    return (app != null) ? app.getRegistrationName() : "";
}

Example 52 with Application

use of com.sun.enterprise.deployment.Application in project Payara by payara.

the class ComponentValidator method accept.

@Override
protected void accept(EjbReference ejbRef) {
    DOLUtils.getDefaultLogger().fine("Visiting Ref" + ejbRef);
    if (ejbRef.getEjbDescriptor() != null)
        return;
    // let's try to derive the ejb-ref-type first it is not defined
    if (ejbRef.getType() == null) {
        // if it's EJB30 (no home/local home), it must be session
        if (ejbRef.isEJB30ClientView()) {
            ejbRef.setType("Session");
        } else {
            // if home interface has findByPrimaryKey method,
            // it's entity, otherwise it's session
            String homeIntf = ejbRef.getEjbHomeInterface();
            BundleDescriptor referringJar = ejbRef.getReferringBundleDescriptor();
            if (referringJar == null) {
                referringJar = getBundleDescriptor();
            }
            ClassLoader classLoader = referringJar.getClassLoader();
            Class<?> clazz = null;
            try {
                clazz = classLoader.loadClass(homeIntf);
                for (Method method : clazz.getDeclaredMethods()) {
                    if (method.getName().equals("findByPrimaryKey")) {
                        ejbRef.setType("Entity");
                        break;
                    }
                }
                if (ejbRef.getType() == null) {
                    ejbRef.setType("Session");
                }
            } catch (Exception e) {
                LogRecord lr = new LogRecord(Level.FINE, LOAD_ERROR);
                Object[] args = { homeIntf };
                lr.setParameters(args);
                lr.setThrown(e);
                deplLogger.log(lr);
            }
        }
    }
    if (ejbRef.getJndiName() != null && ejbRef.getJndiName().length() != 0) {
        // if this is a local ref, proceed with resolution only if ejb-link is null
        if (!ejbRef.isLocal() || (ejbRef.isLocal() && ejbRef.getLinkName() == null)) {
            DOLUtils.getDefaultLogger().fine("Ref " + ejbRef.getName() + " is bound to Ejb with JNDI Name " + ejbRef.getJndiName());
            if (getEjbDescriptors() != null) {
                for (Iterator iter = getEjbDescriptors().iterator(); iter.hasNext(); ) {
                    EjbDescriptor ejb = (EjbDescriptor) iter.next();
                    if (ejbRef.getJndiName().equals(ejb.getJndiName())) {
                        ejbRef.setEjbDescriptor(ejb);
                        return;
                    }
                }
            }
        }
    }
    // and let the existing error-checking logic kick in.
    if (((ejbRef.getJndiName() == null) || (ejbRef.getJndiName().length() == 0)) && ((ejbRef.getLinkName() == null) || (ejbRef.getLinkName().length() == 0)) && !ejbRef.hasLookupName()) {
        Map<String, EjbIntfInfo> ejbIntfInfoMap = getEjbIntfMap();
        if (ejbIntfInfoMap.size() > 0) {
            String interfaceToMatch = ejbRef.isEJB30ClientView() ? ejbRef.getEjbInterface() : ejbRef.getEjbHomeInterface();
            if (interfaceToMatch == null) {
                String msg = localStrings.getLocalString("enterprise.deployment.util.no_remoteinterface", "Cannot resolve reference {0} because it does not declare a remote interface or " + "remote home interface of target bean", new Object[] { ejbRef });
                throw new IllegalArgumentException(msg);
            }
            EjbIntfInfo intfInfo = ejbIntfInfoMap.get(interfaceToMatch);
            // make sure exactly one match
            if (intfInfo != null) {
                int numMatches = intfInfo.ejbs.size();
                if (numMatches == 1) {
                    EjbDescriptor target = intfInfo.ejbs.iterator().next();
                    BundleDescriptor targetModule = target.getEjbBundleDescriptor();
                    BundleDescriptor sourceModule = ejbRef.getReferringBundleDescriptor();
                    Application app = targetModule.getApplication();
                    // 
                    // It's much cleaner to derive the ejb-link value
                    // and set that instead of the descriptor.  This way,
                    // if there are multiple ejb-jars within the .ear that
                    // each have an ejb with the target bean's ejb-name,
                    // there won't be any ambiguity about which one is
                    // the correct target.  It's not so much a problem
                    // during this phase of the processing, but if the
                    // fully-qualified ejb-link name is required and is not
                    // written out, there could be non-deterministic
                    // behavior when the application is re-loaded.
                    // Let the ejb-link processing logic handle the
                    // conversion to ejb descriptor.
                    // 
                    // If the ejb reference and the target ejb are defined
                    // within the same ejb-jar, the ejb-link will only
                    // be set to ejb-name.  This is done regardless of
                    // whether the ejb-jar is within an .ear or is
                    // stand-alone.  The ejb-link processing
                    // logic will always check the current ejb-jar
                    // first so there won't be any ambiguity.
                    String ejbLinkName = target.getName();
                    if (!sourceModule.isPackagedAsSingleModule(targetModule)) {
                        String relativeUri = null;
                        if (sourceModule == app) {
                            // Now that dependencies can be defined within application.xml
                            // it's possible for source module to be the Application object.
                            // In this case, just use the target module uri as the relative
                            // uri.
                            relativeUri = targetModule.getModuleDescriptor().getArchiveUri();
                        } else {
                            // Since there are at least two modules, we
                            // must be within an application.
                            relativeUri = getApplication().getRelativeUri(sourceModule, targetModule);
                        }
                        ejbLinkName = relativeUri + "#" + ejbLinkName;
                    }
                    ejbRef.setLinkName(ejbLinkName);
                } else {
                    String msg = localStrings.getLocalString("enterprise.deployment.util.multiple_ejbs_with_interface", "Cannot resolve reference {0} because there are {1} ejbs in the application with interface {2}.", new Object[] { ejbRef, numMatches, interfaceToMatch });
                    throw new IllegalArgumentException(msg);
                }
            }
        }
    }
    // now all cases fall back here, we need to resolve through the link-name
    if (ejbRef.getLinkName() == null) {
        // local refs within the app and we cannot resolve it
        if (ejbRef.isLocal()) {
            if (ejbRef.hasLookupName()) {
                return;
            }
            DOLUtils.getDefaultLogger().severe("Cannot resolve reference " + ejbRef);
            throw new RuntimeException("Cannot resolve reference " + ejbRef);
        } else {
            // ejb ref, apply default jndi name if there is none
            if (!ejbRef.hasJndiName() && !ejbRef.hasLookupName()) {
                String jndiName = getDefaultEjbJndiName(ejbRef.isEJB30ClientView() ? ejbRef.getEjbInterface() : ejbRef.getEjbHomeInterface());
                ejbRef.setJndiName(jndiName);
                DOLUtils.getDefaultLogger().fine("Applying default to ejb reference: " + ejbRef);
            }
            return;
        }
    }
    // Beginning of ejb-link resolution
    // save anticipated types for checking if interfaces are compatible
    String homeClassName = ejbRef.getEjbHomeInterface();
    String intfClassName = ejbRef.getEjbInterface();
    // save anticipated type for checking if bean type is compatible
    String type = ejbRef.getType();
    EjbDescriptor ejbReferee = null;
    String linkName = ejbRef.getLinkName();
    int ind = linkName.lastIndexOf('#');
    if (ind != -1) {
        // link has a relative path from referring EJB JAR,
        // of form "../products/product.jar#ProductEJB"
        String ejbName = linkName.substring(ind + 1);
        String jarPath = linkName.substring(0, ind);
        BundleDescriptor referringJar = ejbRef.getReferringBundleDescriptor();
        if (referringJar == null) {
            ejbRef.setReferringBundleDescriptor(getBundleDescriptor());
            referringJar = getBundleDescriptor();
        }
        if (getApplication() != null) {
            BundleDescriptor refereeJar = null;
            if (referringJar instanceof Application) {
                refereeJar = ((Application) referringJar).getModuleByUri(jarPath);
            } else {
                refereeJar = getApplication().getRelativeBundle(referringJar, jarPath);
            }
            if ((refereeJar != null) && refereeJar instanceof EjbBundleDescriptor) {
                // this will throw an exception if ejb is not found
                ejbReferee = ((EjbBundleDescriptor) refereeJar).getEjbByName(ejbName);
            }
        }
    } else {
        // Handle an unqualified ejb-link, which is just an ejb-name.
        // If we're in an application and currently processing an
        // ejb-reference defined within an ejb-jar, first check
        // the current ejb-jar for an ejb-name match.  From a spec
        // perspective, the deployer can't depend on this behavior,
        // but it's still better to have deterministic results.  In
        // addition, in the case of automatic-linking, the fully-qualified
        // "#" ejb-link syntax is not used when the ejb reference and
        // target ejb are within the same ejb-jar.  Checking the
        // ejb-jar first will ensure the correct linking behavior for
        // that case.
        Application app = getApplication();
        EjbBundleDescriptor ebd = getEjbBundleDescriptor();
        if (app != null && ebd != null && ebd.hasEjbByName(linkName)) {
            ejbReferee = ebd.getEjbByName(linkName);
        } else if (app != null && app.hasEjbByName(linkName)) {
            ejbReferee = app.getEjbByName(ejbRef.getLinkName());
        } else if (getEjbDescriptor() != null) {
            try {
                ejbReferee = getEjbDescriptor().getEjbBundleDescriptor().getEjbByName(ejbRef.getLinkName());
            } catch (IllegalArgumentException e) {
                // this may happen when we have no application and the ejb ref
                // cannot be resolved to a ejb in the bundle. The ref will
                // probably be resolved when the application is assembled.
                DOLUtils.getDefaultLogger().warning("Unresolved <ejb-link>: " + linkName);
                return;
            }
        }
    }
    if (ejbReferee == null) {
        // a warning should suffice
        if (ejbRef.isLocal()) {
            DOLUtils.getDefaultLogger().severe("Unresolved <ejb-link>: " + linkName);
            throw new RuntimeException("Error: Unresolved <ejb-link>: " + linkName);
        } else {
            final ArchiveType moduleType = ejbRef.getReferringBundleDescriptor().getModuleType();
            if (moduleType != null && moduleType.equals(DOLUtils.carType())) {
                // Because no annotation processing is done within ACC runtime, this case typically
                // arises for remote @EJB annotations, so don't log it as warning.
                DOLUtils.getDefaultLogger().fine("Unresolved <ejb-link>: " + linkName);
            } else {
                DOLUtils.getDefaultLogger().warning("Unresolved <ejb-link>: " + linkName);
            }
            return;
        }
    } else {
        if (ejbRef.isEJB30ClientView()) {
            BundleDescriptor referringBundle = ejbRef.getReferringBundleDescriptor();
            // it must be remote business.
            if (((referringBundle == null) && (getEjbBundleDescriptor() == null)) || ((referringBundle != null) && (referringBundle.getModuleType() == DOLUtils.carType())) || ((getApplication() == null) && (referringBundle.getModuleType() != null && referringBundle.getModuleType().equals(DOLUtils.warType())))) {
                ejbRef.setLocal(false);
                if (!ejbReferee.getRemoteBusinessClassNames().contains(intfClassName)) {
                    String msg = "Target ejb " + ejbReferee.getName() + " for " + " remote ejb 3.0 reference " + ejbRef.getName() + " does not expose a remote business interface of type " + intfClassName;
                    throw new RuntimeException(msg);
                }
            } else if (ejbReferee.getLocalBusinessClassNames().contains(intfClassName)) {
                ejbRef.setLocal(true);
            } else if (ejbReferee.getRemoteBusinessClassNames().contains(intfClassName)) {
                ejbRef.setLocal(false);
            } else {
                if (ejbReferee.isLocalBean()) {
                    ejbRef.setLocal(true);
                } else {
                    String msg = "Warning : Unable to determine local " + " business vs. remote business designation for " + " EJB 3.0 ref " + ejbRef;
                    throw new RuntimeException(msg);
                }
            }
        }
        ejbRef.setEjbDescriptor(ejbReferee);
    }
    // if we are here, we must have resolved the reference
    if (DOLUtils.getDefaultLogger().isLoggable(Level.FINE)) {
        if (getEjbDescriptor() != null) {
            DOLUtils.getDefaultLogger().fine("Done Visiting " + getEjbDescriptor().getName() + " reference " + ejbRef);
        }
    }
    // if there is a target ejb descriptor available
    if (ejbRef.isEJB30ClientView()) {
        Set<String> targetBusinessIntfs = ejbRef.isLocal() ? ejbReferee.getLocalBusinessClassNames() : ejbReferee.getRemoteBusinessClassNames();
        EjbDescriptor ejbDesc = ejbRef.getEjbDescriptor();
        // If it's neither a business interface nor a no-interface view
        if (!targetBusinessIntfs.contains(intfClassName) && (ejbDesc.isLocalBean() && !(intfClassName.equals(ejbReferee.getEjbClassName())))) {
            DOLUtils.getDefaultLogger().log(Level.WARNING, "enterprise.deployment.backend.ejbRefTypeMismatch", new Object[] { ejbRef.getName(), intfClassName, ejbReferee.getName(), (ejbRef.isLocal() ? "Local Business" : "Remote Business"), targetBusinessIntfs.toString() });
            // if there is only 1 target remote/local business intf.
            if (targetBusinessIntfs.size() == 1) {
                Iterator iter = targetBusinessIntfs.iterator();
                ejbRef.setEjbInterface((String) iter.next());
            }
        }
    } else {
        String targetHome = ejbRef.isLocal() ? ejbReferee.getLocalHomeClassName() : ejbReferee.getHomeClassName();
        if (!homeClassName.equals(targetHome)) {
            DOLUtils.getDefaultLogger().log(Level.WARNING, "enterprise.deployment.backend.ejbRefTypeMismatch", new Object[] { ejbRef.getName(), homeClassName, ejbReferee.getName(), (ejbRef.isLocal() ? "Local Home" : "Remote Home"), targetHome });
            if (targetHome != null) {
                ejbRef.setEjbHomeInterface(targetHome);
            }
        }
        String targetComponentIntf = ejbRef.isLocal() ? ejbReferee.getLocalClassName() : ejbReferee.getRemoteClassName();
        // check if the intf is known.
        if ((intfClassName != null) && !intfClassName.equals(targetComponentIntf)) {
            DOLUtils.getDefaultLogger().log(Level.WARNING, "enterprise.deployment.backend.ejbRefTypeMismatch", new Object[] { ejbRef.getName(), intfClassName, ejbReferee.getName(), (ejbRef.isLocal() ? "Local" : "Remote"), targetComponentIntf });
            if (targetComponentIntf != null) {
                ejbRef.setEjbInterface(targetComponentIntf);
            }
        }
    }
    // set jndi name in ejb ref
    ejbRef.setJndiName(ejbReferee.getJndiName());
    if (!type.equals(ejbRef.getType())) {
        // if they don't match
        // print a warning and reset the type in ejb ref
        DOLUtils.getDefaultLogger().log(Level.WARNING, DOLUtils.INVALID_DESC_MAPPING, new Object[] { ejbRef.getName(), type });
        ejbRef.setType(ejbRef.getType());
    }
}

Example 53 with Application

use of com.sun.enterprise.deployment.Application in project Payara by payara.

the class DOLUtils method getLibraryJarURIs.

/**
 * @param bundleDesc
 * @param archive
 * @return an empty list if bundleDesc is null
 * @throws Exception
 */
public static List<URI> getLibraryJarURIs(BundleDescriptor bundleDesc, ReadableArchive archive) throws Exception {
    if (bundleDesc == null) {
        return Collections.emptyList();
    }
    ModuleDescriptor moduleDesc = ((BundleDescriptor) bundleDesc).getModuleDescriptor();
    Application app = ((BundleDescriptor) moduleDesc.getDescriptor()).getApplication();
    return getLibraryJarURIs(app, archive);
}

Example 54 with Application

use of com.sun.enterprise.deployment.Application in project Payara by payara.

the class DOLUtils method getApplicationName.

/**
 * @param env
 * @return
 */
public static String getApplicationName(JndiNameEnvironment env) {
    String appName = "";
    Application app = getApplicationFromEnv(env);
    if (app != null) {
        appName = app.getAppName();
    } else {
        throw new IllegalArgumentException("IllegalJndiNameEnvironment : env");
    }
    return appName;
}

Example 55 with Application

use of com.sun.enterprise.deployment.Application in project Payara by payara.

the class ApplicationArchivist method getApplicationFromIntrospection.

/**
 * This method introspect an ear file and populate the Application object. We follow the Java EE platform specification,
 * Section EE.8.4.2 to determine the type of the modules included in this application.
 *
 * @param archive
 *            the archive representing the application root
 * @param directory
 *            whether this is a directory deployment
 */
private Application getApplicationFromIntrospection(ReadableArchive archive, boolean directory) {
    // archive is a directory
    String appRoot = archive.getURI().getSchemeSpecificPart();
    if (appRoot.endsWith(File.separator)) {
        appRoot = appRoot.substring(0, appRoot.length() - 1);
    }
    Application app = Application.createApplication();
    app.setLoadedFromApplicationXml(false);
    app.setVirtual(false);
    // name of the file without its extension
    String appName = appRoot.substring(appRoot.lastIndexOf(File.separatorChar) + 1);
    app.setName(appName);
    List<ReadableArchive> unknowns = new ArrayList<ReadableArchive>();
    File[] files = getEligibleEntries(new File(appRoot), directory);
    for (File subModule : files) {
        ReadableArchive subArchive = null;
        try {
            try {
                subArchive = archiveFactory.openArchive(subModule);
            } catch (IOException ex) {
                logger.log(Level.WARNING, ex.getMessage());
            }
            // for archive deployment, we check the sub archives by its
            // file extension; for directory deployment, we check the sub
            // directories by its name. We are now supporting directory
            // names with both "_suffix" and ".suffix".
            // Section EE.8.4.2.1.a
            String name = subModule.getName();
            String uri = deriveArchiveUri(appRoot, subModule, directory);
            if ((!directory && name.endsWith(".war")) || (directory && (name.endsWith("_war") || name.endsWith(".war")))) {
                ModuleDescriptor<BundleDescriptor> md = new ModuleDescriptor<BundleDescriptor>();
                md.setArchiveUri(uri);
                md.setModuleType(DOLUtils.warType());
                // the context root will be set later after
                // we process the sub modules
                app.addModule(md);
            } else // Section EE.8.4.2.1.b
            if ((!directory && name.endsWith(".rar")) || (directory && (name.endsWith("_rar") || name.endsWith(".rar")))) {
                ModuleDescriptor<BundleDescriptor> md = new ModuleDescriptor<BundleDescriptor>();
                md.setArchiveUri(uri);
                md.setModuleType(DOLUtils.rarType());
                app.addModule(md);
            } else if ((!directory && name.endsWith(".jar")) || (directory && (name.endsWith("_jar") || name.endsWith(".jar")))) {
                try {
                    // Section EE.8.4.2.1.d.i
                    AppClientArchivist acArchivist = new AppClientArchivist();
                    if (acArchivist.hasStandardDeploymentDescriptor(subArchive) || acArchivist.hasRuntimeDeploymentDescriptor(subArchive) || acArchivist.getMainClassName(subArchive.getManifest()) != null) {
                        ModuleDescriptor<BundleDescriptor> md = new ModuleDescriptor<BundleDescriptor>();
                        md.setArchiveUri(uri);
                        md.setModuleType(DOLUtils.carType());
                        md.setManifest(subArchive.getManifest());
                        app.addModule(md);
                        continue;
                    }
                    // Section EE.8.4.2.1.d.ii
                    Archivist ejbArchivist = archivistFactory.get().getArchivist(DOLUtils.ejbType());
                    if (ejbArchivist.hasStandardDeploymentDescriptor(subArchive) || ejbArchivist.hasRuntimeDeploymentDescriptor(subArchive)) {
                        ModuleDescriptor<BundleDescriptor> md = new ModuleDescriptor<BundleDescriptor>();
                        md.setArchiveUri(uri);
                        md.setModuleType(DOLUtils.ejbType());
                        app.addModule(md);
                        continue;
                    }
                } catch (IOException ex) {
                    logger.log(Level.WARNING, ex.getMessage());
                }
                // Still could not decide between an ejb and a library
                unknowns.add(subArchive);
                // Prevent this unknown archive from being closed in the
                // finally block, because the same object will be used in
                // the block below where unknowns are checked one more time.
                subArchive = null;
            } else {
            // ignored
            }
        } finally {
            if (subArchive != null) {
                try {
                    subArchive.close();
                } catch (IOException ioe) {
                    logger.log(Level.WARNING, localStrings.getLocalString("enterprise.deployment.errorClosingSubArch", "Error closing subarchive {0}", new Object[] { subModule.getAbsolutePath() }), ioe);
                }
            }
        }
    }
    if (unknowns.size() > 0) {
        AnnotationDetector detector = new AnnotationDetector(new EjbComponentAnnotationScanner());
        for (int i = 0; i < unknowns.size(); i++) {
            File jarFile = new File(unknowns.get(i).getURI().getSchemeSpecificPart());
            try {
                if (detector.hasAnnotationInArchive(unknowns.get(i))) {
                    String uri = deriveArchiveUri(appRoot, jarFile, directory);
                    // Section EE.8.4.2.1.d.ii, alas EJB
                    ModuleDescriptor<BundleDescriptor> md = new ModuleDescriptor<BundleDescriptor>();
                    md.setArchiveUri(uri);
                    md.setModuleType(DOLUtils.ejbType());
                    app.addModule(md);
                }
                /*
                     * The subarchive was opened by the anno detector. Close it.
                     */
                unknowns.get(i).close();
            } catch (IOException ex) {
                logger.log(Level.WARNING, ex.getMessage());
            }
        }
    }
    return app;
}