public EnvEntry(final String envEntryName, final String envEntryType, final String envEntryValue) { this.setEnvEntryName(envEntryName); this.setEnvEntryType(envEntryType); this.setEnvEntryValue(envEntryValue); }
@Override public String toString() { return "EnvEntry{" + "name='" + getEnvEntryName() + '\'' + ", type='" + getEnvEntryType() + '\'' + ", value='" + getEnvEntryValue() + '\'' + ", mappedName='" + getMappedName() + '\'' + ", lookupName='" + getLookupName() + '\'' + '}'; } }
public EnvEntry injectionTarget(final String className, final String property) { getInjectionTarget().add(new InjectionTarget(className, property)); if (this.getEnvEntryName() == null) { this.setEnvEntryName("java:comp/env/" + className + "/" + property); } return this; }
EnvEntry envEntry = webApp.getEnvEntryMap().get(environment.getName()); if (envEntry == null) { envEntry = new EnvEntry(); envEntry.setName(environment.getName()); webApp.getEnvEntry().add(envEntry); envEntry.setEnvEntryValue(environment.getValue()); envEntry.setEnvEntryType(environment.getType());
envEntry = new EnvEntry(); envEntry.setEnvEntryName(resourceName); envEntry.setEnvEntryType(deprimitivize(resourceType).getCanonicalName()); envEntry.setMappedName(mappdedNameAnnotation); envEntry.setDescriptions(new Text[] {new Text(null, descriptionAnnotation)}); envEntry.setLookupName(lookup); Set<InjectionTarget> targets = envEntry.getInjectionTarget(); if (!hasTarget(method, field, targets)) { envEntry.getInjectionTarget().add(configureInjectionTarget(method, field));
private <R extends JndiReference> void copy(final Map<String, R> from, final Map<String, R> to) { for (final R a : from.values()) { if (isPrivateReference(a)) { continue; } final R b = to.get(a.getKey()); // New entry if (b == null) { if (!isExtendedPersistenceContext(a)) { to.put(a.getKey(), a); } continue; } // Update existing entry // merge injection points b.getInjectionTarget().addAll(a.getInjectionTarget()); // merge env-entry values if (b instanceof EnvEntry && a instanceof EnvEntry) { final EnvEntry eb = (EnvEntry) b; final EnvEntry ea = (EnvEntry) a; if (eb.getEnvEntryValue() == null) { eb.setEnvEntryValue(ea.getEnvEntryValue()); } if (eb.getEnvEntryType() == null) { eb.setEnvEntryType(ea.getEnvEntryType()); } } } }
private List<EnvEntryInfo> buildEnvEntryInfos(JndiConsumer item) { List<EnvEntryInfo> infos = new ArrayList<EnvEntryInfo>(); for (EnvEntry env : item.getEnvEntry()) { // ignore env entries without a value if (env.getEnvEntryValue() == null) { continue; } if (env.getEnvEntryType() == null){ // TODO: Maybe Move this into the EnvEntry class env.setEnvEntryType("java.lang.String"); } EnvEntryInfo info = new EnvEntryInfo(); info.name = env.getEnvEntryName(); info.type = env.getEnvEntryType(); info.value = env.getEnvEntryValue(); info.location = buildLocationInfo(env); info.targets.addAll(buildInjectionInfos(env)); infos.add(info); } return infos; }
private void removeUnsetEnvEntries(final Map<String, EnvEntry> appEntries, final JndiConsumer consumer) { final Iterator<EnvEntry> entries = consumer.getEnvEntry().iterator(); while (entries.hasNext()) { final EnvEntry entry = entries.next(); if (entry.getEnvEntryValue() != null || entry.getLookupName() != null) { continue; } final EnvEntry appEntry = appEntries.get(entry.getName()); if (appEntry != null && appEntry.getEnvEntryValue() != null) { entry.setEnvEntryValue(appEntry.getEnvEntryValue()); } else { entries.remove(); } } }
private void apply(JndiConsumer bean, EnvEntry newEntry, String componentName) { EnvEntry entry = bean.getEnvEntryMap().get(newEntry.getName()); if (entry != null){ log.debug("envprops.override", componentName, entry.getName(), entry.getEnvEntryValue(), newEntry.getEnvEntryValue()); entry.setEnvEntryValue(newEntry.getEnvEntryValue()); return; } // Must not be an override, just add the new entry log.debug("envprops.add", componentName, newEntry.getName(), newEntry.getEnvEntryValue()); bean.getEnvEntry().add(newEntry); }
if (module.getApplicationClient() == null) continue; for (Map.Entry<String, String> entry : getEnvEntries(module).entrySet()) { EnvEntry envEntry = new EnvEntry(entry.getKey(), "java.lang.String", entry.getValue()); apply(module.getApplicationClient(), envEntry, "AppClient"); EnvEntry envEntry = new EnvEntry(entry.getKey(), "java.lang.String", entry.getValue()); if (envEntry.getName().contains(".")) { String name = envEntry.getName(); String ejbName = name.substring(0,name.indexOf('.')); name = name.substring(name.indexOf('.')+1); if (bean != null){ envEntry.setName(name); apply(bean, envEntry, bean.getEjbName()); continue;
addInjections(normalize(name), ReferenceType.ENV_ENTRY, envEntry.getInjectionTarget(), NamingBuilder.INJECTION_KEY.get(sharedContext)); continue; String type = getStringValue(envEntry.getEnvEntryType()); String strValue = null; if (strValueOverride == null) { strValue = envEntry.getEnvEntryValue(); String lookupName = getStringValue(envEntry.getLookupName()); if (strValue != null && lookupName != null) { throw new DeploymentException("You must specify an environment entry value or lookup name but not both. Component: " + module.toString() + ", name: " + name + ", env-entry-value: " + strValue + ", lookup-name: " + lookupName + ""); type = inferAndCheckType(module, bundle, envEntry.getInjectionTarget(), name, type); put(name, value, ReferenceType.ENV_ENTRY, module.getJndiContext(), envEntry.getInjectionTarget(), sharedContext); } else if(isSharableJndiNamespace(name)) { addInjections(normalize(name), ReferenceType.ENV_ENTRY, envEntry.getInjectionTarget(), NamingBuilder.INJECTION_KEY.get(sharedContext));
final EnvEntry envEntry = new EnvEntry(); envEntry.setName(refName); consumer.getEnvEntry().add(envEntry); envEntry.setLookupName(lookupName); final EnvEntry envEntry = new EnvEntry(); envEntry.setName(refName); consumer.getEnvEntry().add(envEntry); reference = envEntry; final EnvEntry envEntry = new EnvEntry(); envEntry.setName(refName); consumer.getEnvEntry().add(envEntry); reference = envEntry;
public EnvEntry type(final String envEntryType) { this.setEnvEntryType(envEntryType); return this; }
private void add(final JndiConsumer jndi, final DeploymentModule module, final DeploymentModule app) { // Standard names add(jndi.getEnvEntryMap(), new EnvEntry().name("java:module/ModuleName").value(module.getModuleId()).type(String.class)); add(jndi.getEnvEntryMap(), new EnvEntry().name("java:app/AppName").value(app.getModuleId()).type(String.class)); // Standard References to built-in objects add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/BeanManager").type(BeanManager.class)); add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/Validator").type(Validator.class)); add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/ValidatorFactory").type(ValidatorFactory.class)); add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionManager").type(TransactionManager.class)); add(jndi.getResourceEnvRefMap(), new ResourceEnvRef().name("java:comp/TransactionSynchronizationRegistry").type(TransactionSynchronizationRegistry.class)); // OpenEJB specific feature add(jndi.getEnvEntryMap(), new EnvEntry().name("java:comp/ComponentName").value(jndi.getJndiConsumerName()).type(String.class)); }
private void fillInMissingType(final ClassLoader loader, final EnvEntry entry) { if (entry.getType() != null) { return; } // If it has the lookup supplied we don't care if there is no type if (entry.getLookupName() != null) { return; } // We can't imply type without at least one injection point if (entry.getInjectionTarget().size() == 0) { return; } final Set<Class> types = new HashSet<Class>(); for (final InjectionTarget target : entry.getInjectionTarget()) { if (target.getInjectionTargetClass() == null) { continue; } if (target.getInjectionTargetName() == null) { continue; } types.add(getType(loader, target)); } normalize(types); final Class<?> type = types.size() == 1 ? types.iterator().next() : String.class; entry.setType(type.getName()); }
if ("java:comp/env/implementingInterfaceClass".equals(entry.getName())) { entry.setEnvEntryValue(ejbClass.getName());
@Override public void preProcessWebXmlElement(WebApp webApp, MergeContext mergeContext) throws DeploymentException { for (EnvEntry envEntry : webApp.getEnvEntry()) { String envEntryName = envEntry.getEnvEntryName(); mergeContext.setAttribute(createEnvEntryKey(envEntryName), new MergeItem(envEntry, null, ElementSource.WEB_XML)); //Create an attribute tag to indicate whether injectTarget is configured in web.xml file if (envEntry.getInjectionTarget().size() > 0) { mergeContext.setAttribute(createEnvEntryInjectTargetConfiguredInWebXMLKey(envEntryName), Boolean.TRUE); } for (InjectionTarget injectionTarget : envEntry.getInjectionTarget()) { mergeContext.setAttribute(createEnvEntryInjectTargetKey(envEntryName, injectionTarget.getInjectionTargetClass(), injectionTarget.getInjectionTargetName() ), Boolean.TRUE); } } }
final String name = entry.getName(); final String jndi; if (name.startsWith("java:") || name.startsWith("comp/env")) { jndi = "java:comp/env/" + name; jndiContext.bind(jndi, entry.getEnvEntryValue());
public WebModule deploy(final WebModule webModule) { for (final Map.Entry<String, String> entry : getEnvEntries(webModule).entrySet()) { final EnvEntry envEntry = new EnvEntry(entry.getKey(), "java.lang.String", entry.getValue()); apply(webModule.getWebApp(), envEntry, "WebApp"); } return webModule; }
@XmlTransient public String getType() { return getEnvEntryType(); }