Examples with OpenEJBRuntimeException org.apache.openejb.OpenEJBRuntimeException used on opensource projects

Example 46 with OpenEJBRuntimeException

use of org.apache.openejb.OpenEJBRuntimeException in project tomee by apache.

the class HessianExtension method deploy.

protected void deploy(@Observes final AfterDeploymentValidation afterDeploymentValidation, final BeanManager bm) {
    final HessianService service = SystemInstance.get().getComponent(HessianService.class);
    if (service == null) {
        LOGGER.severe("HessianService not yet started, no hessian CDI webservices will be deployed");
        return;
    }
    final HessianRegistry registry = service.getRegistry();
    final String appName = findAppName();
    for (final Deployment deployment : toDeploy) {
        final Hessian hessian = deployment.itf.getAnnotation(Hessian.class);
        final HessianServer server;
        try {
            server = new HessianServer(deployment.bean.getBeanClass().getClassLoader());
        } catch (final HessianServer.HessianIsMissingException e) {
            LOGGER.info("Hessian is not available so openejb-hessian will not deploy any service");
            break;
        }
        try {
            if (hessian != null && hessian.serializerFactory() != Object.class && !hessian.serializerFactory().isInstance(server.getSerializerFactory())) {
                server.serializerFactory(hessian.serializerFactory().newInstance());
            }
        } catch (final Exception e) {
            throw new OpenEJBRuntimeException(e);
        }
        if (hessian != null) {
            server.sendCollectionType(hessian.sendCollectionType());
        }
        if (Dependent.class.equals(deployment.bean.getScope())) {
            LOGGER.warning("@Dependent can lead to memory leaks ATM");
        }
        server.createSkeleton(bm.getReference(deployment.bean, deployment.itf, null), deployment.itf);
        final String name = getName(deployment.path, deployment.itf);
        try {
            LOGGER.info("Hessian(url=" + registry.deploy(deployment.itf.getClassLoader(), server, service.getVirtualHost(), appName, service.getAuthMethod(), service.getTransportGuarantee(), service.getRealmName(), name) + ", interface=" + name + ")");
            deployed.add(new DeployedEndpoint(appName, name));
        } catch (final URISyntaxException e) {
            throw new OpenEJBRuntimeException(e);
        }
    }
    toDeploy.clear();
}

Example 47 with OpenEJBRuntimeException

use of org.apache.openejb.OpenEJBRuntimeException in project tomee by apache.

the class HessianService method deploy.

private void deploy(final AppInfo app, final Collection<BeanContext> beanContexts) {
    if (disabled) {
        return;
    }
    for (final BeanContext beanContext : beanContexts) {
        final Class<?> remoteItf = beanContext.getBusinessRemoteInterface();
        if (remoteItf == null) {
            continue;
        }
        final ClassLoader old = Thread.currentThread().getContextClassLoader();
        final ClassLoader classLoader = beanContext.getClassLoader();
        Thread.currentThread().setContextClassLoader(classLoader);
        try {
            final HessianServer server;
            try {
                server = new HessianServer(classLoader).debug(debug);
            } catch (final HessianServer.HessianIsMissingException e) {
                LOGGER.info("Hessian is not available so openejb-hessian will not deploy any service");
                break;
            }
            if (serializerFactory != null) {
                try {
                    server.serializerFactory(classLoader.loadClass(serializerFactory).newInstance()).sendCollectionType(sendCollectionType);
                } catch (final Exception e) {
                    throw new OpenEJBRuntimeException(e);
                }
            } else {
                server.sendCollectionType(sendCollectionType);
            }
            server.createSkeleton(ProxyEJB.simpleProxy(beanContext, new Class<?>[] { remoteItf }), remoteItf);
            try {
                LOGGER.info("Hessian(url=" + registry.deploy(classLoader, server, virtualHost, appName(app, beanContext), authMethod, transportGuarantee, realmName, String.class.cast(beanContext.getDeploymentID())) + ", interface=" + remoteItf.getName() + ")");
            } catch (final URISyntaxException e) {
                throw new OpenEJBRuntimeException(e);
            }
        } finally {
            Thread.currentThread().setContextClassLoader(old);
        }
    }
}

Example 48 with OpenEJBRuntimeException

use of org.apache.openejb.OpenEJBRuntimeException in project tomee by apache.

the class EjbTimerServiceImpl method getDefaultScheduler.

public static synchronized Scheduler getDefaultScheduler(final BeanContext deployment) {
    Scheduler scheduler = deployment.get(Scheduler.class);
    if (scheduler != null) {
        boolean valid;
        try {
            valid = !scheduler.isShutdown();
        } catch (final Exception ignored) {
            valid = false;
        }
        if (valid) {
            return scheduler;
        }
    }
    Scheduler thisScheduler;
    synchronized (deployment.getId()) {
        // should be done only once so no perf issues
        scheduler = deployment.get(Scheduler.class);
        if (scheduler != null) {
            return scheduler;
        }
        final Properties properties = new Properties();
        int quartzProps = 0;
        quartzProps += putAll(properties, SystemInstance.get().getProperties());
        quartzProps += putAll(properties, deployment.getModuleContext().getAppContext().getProperties());
        quartzProps += putAll(properties, deployment.getModuleContext().getProperties());
        quartzProps += putAll(properties, deployment.getProperties());
        // custom config -> don't use default/global scheduler
        // if one day we want to keep a global config for a global scheduler (SystemInstance.get().getProperties()) we'll need to manage resume/pause etc correctly by app
        // since we have a scheduler by ejb today in such a case we don't need
        final boolean newInstance = quartzProps > 0;
        final SystemInstance systemInstance = SystemInstance.get();
        scheduler = systemInstance.getComponent(Scheduler.class);
        if (scheduler == null || newInstance) {
            final boolean useTccl = "true".equalsIgnoreCase(properties.getProperty(OPENEJB_QUARTZ_USE_TCCL, "false"));
            defaultQuartzConfiguration(properties, deployment, newInstance, useTccl);
            try {
                // start in container context to avoid thread leaks
                final ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
                if (useTccl) {
                    Thread.currentThread().setContextClassLoader(deployment.getClassLoader());
                } else {
                    Thread.currentThread().setContextClassLoader(EjbTimerServiceImpl.class.getClassLoader());
                }
                try {
                    thisScheduler = new StdSchedulerFactory(properties).getScheduler();
                    thisScheduler.start();
                } finally {
                    Thread.currentThread().setContextClassLoader(oldCl);
                }
                // durability is configured with true, which means that the job will be kept in the store even if no trigger is attached to it.
                // Currently, all the EJB beans share with the same job instance
                final JobDetail job = JobBuilder.newJob(EjbTimeoutJob.class).withIdentity(OPENEJB_TIMEOUT_JOB_NAME, OPENEJB_TIMEOUT_JOB_GROUP_NAME).storeDurably(true).requestRecovery(false).build();
                thisScheduler.addJob(job, true);
            } catch (final SchedulerException e) {
                throw new OpenEJBRuntimeException("Fail to initialize the default scheduler", e);
            }
            if (!newInstance) {
                systemInstance.setComponent(Scheduler.class, thisScheduler);
            }
        } else {
            thisScheduler = scheduler;
        }
        deployment.set(Scheduler.class, thisScheduler);
    }
    return thisScheduler;
}

Example 49 with OpenEJBRuntimeException

use of org.apache.openejb.OpenEJBRuntimeException in project tomee by apache.

the class UriResolver method tryFileSystem.

private void tryFileSystem(final String baseUriStr, final String uriStr) throws IOException, MalformedURLException {
    final URI relative;
    File uriFile = new File(uriStr);
    uriFile = new File(uriFile.getAbsolutePath());
    if (uriFile.exists()) {
        relative = uriFile.toURI();
    } else {
        relative = URLs.uri(uriStr);
    }
    if (relative.isAbsolute()) {
        uri = relative;
        url = relative.toURL();
        try {
            final HttpURLConnection huc = (HttpURLConnection) url.openConnection();
            final String host = JavaSecurityManagers.getSystemProperty("http.proxyHost");
            if (host != null) {
                // comment out unused port to pass pmd check
                /*String ports = JavaSecurityManagers.getSystemProperty("http.proxyPort");
                    int port = 80;
                    if (ports != null) {
                        port = Integer.parseInt(ports);
                    }*/
                final String username = JavaSecurityManagers.getSystemProperty("http.proxy.user");
                final String password = JavaSecurityManagers.getSystemProperty("http.proxy.password");
                if (username != null && password != null) {
                    final String encoded = new String(Base64.encodeBase64((username + ":" + password).getBytes()));
                    huc.setRequestProperty("Proxy-Authorization", "Basic " + encoded);
                }
            }
            is = huc.getInputStream();
        } catch (final ClassCastException ex) {
            is = IO.read(url);
        }
    } else if (baseUriStr != null) {
        URI base;
        File baseFile = new File(baseUriStr);
        if (!baseFile.exists() && baseUriStr.startsWith("file:/")) {
            baseFile = new File(baseUriStr.substring(6));
        }
        if (baseFile.exists()) {
            base = baseFile.toURI();
        } else {
            base = URLs.uri(baseUriStr);
        }
        base = base.resolve(relative);
        if (base.isAbsolute()) {
            try {
                baseFile = new File(base);
                if (baseFile.exists()) {
                    is = IO.read(base.toURL());
                    uri = base;
                } else {
                    tryClasspath(base.toString().startsWith("file:") ? base.toString().substring(5) : base.toString());
                }
            } catch (final Throwable th) {
                tryClasspath(base.toString().startsWith("file:") ? base.toString().substring(5) : base.toString());
            }
        }
    }
    if (uri != null && "file".equals(uri.getScheme())) {
        try {
            file = new File(uri);
        } catch (final IllegalArgumentException iae) {
            file = URLs.toFile(uri.toURL());
            if (!file.exists()) {
                file = null;
            }
        }
    }
    if (is == null && file != null && file.exists()) {
        uri = file.toURI();
        try {
            is = new FileInputStream(file);
        } catch (final FileNotFoundException e) {
            throw new OpenEJBRuntimeException("File was deleted! " + uriStr, e);
        }
        url = file.toURI().toURL();
    } else if (is == null) {
        tryClasspath(uriStr);
    }
}

Example 50 with OpenEJBRuntimeException

use of org.apache.openejb.OpenEJBRuntimeException in project tomee by apache.

the class LightweightWebAppBuilder method deployWebApps.

@Override
public void deployWebApps(final AppInfo appInfo, final ClassLoader appClassLoader) throws Exception {
    final CoreContainerSystem cs = (CoreContainerSystem) SystemInstance.get().getComponent(ContainerSystem.class);
    final AppContext appContext = cs.getAppContext(appInfo.appId);
    if (appContext == null) {
        throw new OpenEJBRuntimeException("Can't find app context for " + appInfo.appId);
    }
    for (final WebAppInfo webAppInfo : appInfo.webApps) {
        ClassLoader classLoader = loaderByWebContext.get(webAppInfo.moduleId);
        if (classLoader == null) {
            classLoader = appClassLoader;
        }
        final Set<Injection> injections = new HashSet<Injection>(appContext.getInjections());
        injections.addAll(new InjectionBuilder(classLoader).buildInjections(webAppInfo.jndiEnc));
        final List<BeanContext> beanContexts;
        if (!appInfo.webAppAlone) {
            // add module bindings in app
            final Assembler assembler = SystemInstance.get().getComponent(Assembler.class);
            beanContexts = assembler.initEjbs(classLoader, appInfo, appContext, injections, new ArrayList<BeanContext>(), webAppInfo.moduleId);
            appContext.getBeanContexts().addAll(beanContexts);
        } else {
            beanContexts = null;
        }
        final Map<String, Object> bindings = new HashMap<>();
        bindings.putAll(appContext.getBindings());
        bindings.putAll(new JndiEncBuilder(webAppInfo.jndiEnc, injections, webAppInfo.moduleId, "Bean", null, webAppInfo.uniqueId, classLoader, appInfo.properties).buildBindings(JndiEncBuilder.JndiScope.comp));
        final WebContext webContext = new WebContext(appContext);
        webContext.setBindings(bindings);
        webContext.getBindings().putAll(new JndiEncBuilder(webAppInfo.jndiEnc, injections, webAppInfo.moduleId, "Bean", null, webAppInfo.uniqueId, classLoader, appInfo.properties).buildBindings(JndiEncBuilder.JndiScope.comp));
        webContext.setJndiEnc(WebInitialContext.create(bindings, appContext.getGlobalJndiContext()));
        webContext.setClassLoader(classLoader);
        webContext.setId(webAppInfo.moduleId);
        webContext.setContextRoot(webAppInfo.contextRoot);
        webContext.setHost(webAppInfo.host);
        webContext.getInjections().addAll(injections);
        webContext.setInitialContext(new EmbeddedInitialContext(webContext.getJndiEnc(), webContext.getBindings()));
        final ServletContext component = SystemInstance.get().getComponent(ServletContext.class);
        final ServletContextEvent sce = component == null ? new MockServletContextEvent() : new ServletContextEvent(new LightServletContext(component, webContext.getClassLoader()));
        servletContextEvents.put(webAppInfo, sce);
        webContext.setServletContext(sce.getServletContext());
        SystemInstance.get().fireEvent(new EmbeddedServletContextCreated(sce.getServletContext()));
        appContext.getWebContexts().add(webContext);
        cs.addWebContext(webContext);
        if (!appInfo.webAppAlone && hasCdi(appInfo)) {
            final Assembler assembler = SystemInstance.get().getComponent(Assembler.class);
            new CdiBuilder().build(appInfo, appContext, beanContexts, webContext);
            assembler.startEjbs(true, beanContexts);
        }
        // listeners
        for (final ListenerInfo listener : webAppInfo.listeners) {
            final Class<?> clazz = webContext.getClassLoader().loadClass(listener.classname);
            final Object instance = webContext.newInstance(clazz);
            if (ServletContextListener.class.isInstance(instance)) {
                switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                    @Override
                    public void run() {
                        ((ServletContextListener) instance).contextInitialized(sce);
                    }
                });
            }
            List<Object> list = listeners.get(webAppInfo);
            if (list == null) {
                list = new ArrayList<Object>();
                listeners.put(webAppInfo, list);
            }
            list.add(instance);
        }
        for (final ClassListInfo info : webAppInfo.webAnnotatedClasses) {
            final String url = info.name;
            for (final String filterPath : info.list) {
                final Class<?> clazz = loadFromUrls(webContext.getClassLoader(), url, filterPath);
                final WebListener annotation = clazz.getAnnotation(WebListener.class);
                if (annotation != null) {
                    final Object instance = webContext.newInstance(clazz);
                    if (ServletContextListener.class.isInstance(instance)) {
                        switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                            @Override
                            public void run() {
                                ((ServletContextListener) instance).contextInitialized(sce);
                            }
                        });
                    }
                    List<Object> list = listeners.get(webAppInfo);
                    if (list == null) {
                        list = new ArrayList<Object>();
                        listeners.put(webAppInfo, list);
                    }
                    list.add(instance);
                }
            }
        }
        final DeployedWebObjects deployedWebObjects = new DeployedWebObjects();
        deployedWebObjects.webContext = webContext;
        servletDeploymentInfo.put(webAppInfo, deployedWebObjects);
        if (webContext.getWebBeansContext() != null && webContext.getWebBeansContext().getBeanManagerImpl().isInUse()) {
            final Thread thread = Thread.currentThread();
            final ClassLoader old = thread.getContextClassLoader();
            thread.setContextClassLoader(webContext.getClassLoader());
            try {
                OpenEJBLifecycle.class.cast(webContext.getWebBeansContext().getService(ContainerLifecycle.class)).startServletContext(sce.getServletContext());
            } finally {
                thread.setContextClassLoader(old);
            }
        }
        if (addServletMethod == null) {
            // can't manage filter/servlets
            continue;
        }
        // register filters
        for (final FilterInfo info : webAppInfo.filters) {
            switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                @Override
                public void run() {
                    for (final String mapping : info.mappings) {
                        final FilterConfig config = new SimpleFilterConfig(sce.getServletContext(), info.name, info.initParams);
                        try {
                            addFilterMethod.invoke(null, info.classname, webContext, mapping, config);
                            deployedWebObjects.filterMappings.add(mapping);
                        } catch (final Exception e) {
                            LOGGER.warning(e.getMessage(), e);
                        }
                    }
                }
            });
        }
        for (final ClassListInfo info : webAppInfo.webAnnotatedClasses) {
            final String url = info.name;
            for (final String filterPath : info.list) {
                final Class<?> clazz = loadFromUrls(webContext.getClassLoader(), url, filterPath);
                final WebFilter annotation = clazz.getAnnotation(WebFilter.class);
                if (annotation != null) {
                    final Properties initParams = new Properties();
                    for (final WebInitParam param : annotation.initParams()) {
                        initParams.put(param.name(), param.value());
                    }
                    final FilterConfig config = new SimpleFilterConfig(sce.getServletContext(), info.name, initParams);
                    for (final String[] mappings : asList(annotation.urlPatterns(), annotation.value())) {
                        switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                            @Override
                            public void run() {
                                for (final String mapping : mappings) {
                                    try {
                                        addFilterMethod.invoke(null, clazz.getName(), webContext, mapping, config);
                                        deployedWebObjects.filterMappings.add(mapping);
                                    } catch (final Exception e) {
                                        LOGGER.warning(e.getMessage(), e);
                                    }
                                }
                            }
                        });
                    }
                }
            }
        }
        final Map<String, PortInfo> ports = new TreeMap<String, PortInfo>();
        for (final PortInfo port : webAppInfo.portInfos) {
            ports.put(port.serviceLink, port);
        }
        // register servlets
        for (final ServletInfo info : webAppInfo.servlets) {
            if ("true".equalsIgnoreCase(appInfo.properties.getProperty("openejb.jaxrs.on", "true"))) {
                // skip jaxrs servlets
                boolean skip = false;
                for (final ParamValueInfo pvi : info.initParams) {
                    if ("javax.ws.rs.Application".equals(pvi.name) || Application.class.getName().equals(pvi.name)) {
                        skip = true;
                    }
                }
                if (skip) {
                    continue;
                }
                if (info.servletClass == null) {
                    try {
                        if (Application.class.isAssignableFrom(classLoader.loadClass(info.servletName))) {
                            continue;
                        }
                    } catch (final Exception e) {
                    // no-op
                    }
                }
            }
            // If POJO web services, it will be overriden with WsServlet
            if (ports.containsKey(info.servletName) || ports.containsKey(info.servletClass)) {
                continue;
            }
            // deploy
            for (final String mapping : info.mappings) {
                switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                    @Override
                    public void run() {
                        try {
                            addServletMethod.invoke(null, info.servletClass, webContext, mapping);
                            deployedWebObjects.mappings.add(mapping);
                        } catch (final Exception e) {
                            LOGGER.warning(e.getMessage(), e);
                        }
                    }
                });
            }
        }
        for (final ClassListInfo info : webAppInfo.webAnnotatedClasses) {
            final String url = info.name;
            for (final String servletPath : info.list) {
                final Class<?> clazz = loadFromUrls(webContext.getClassLoader(), url, servletPath);
                final WebServlet annotation = clazz.getAnnotation(WebServlet.class);
                if (annotation != null) {
                    for (final String[] mappings : asList(annotation.urlPatterns(), annotation.value())) {
                        switchServletContextIfNeeded(sce.getServletContext(), new Runnable() {

                            @Override
                            public void run() {
                                for (final String mapping : mappings) {
                                    try {
                                        addServletMethod.invoke(null, clazz.getName(), webContext, mapping);
                                        deployedWebObjects.mappings.add(mapping);
                                    } catch (final Exception e) {
                                        LOGGER.warning(e.getMessage(), e);
                                    }
                                }
                            }
                        });
                    }
                }
            }
        }
        if (addDefaults != null && tryJsp()) {
            addDefaults.invoke(null, webContext);
            deployedWebObjects.mappings.add("*\\.jsp");
        }
    }
}