for (Iterator i = source.getAttributes().iterator(); i.hasNext();) { GAttributeInfo attributeInfo = (GAttributeInfo) i.next(); attributes.put(attributeInfo.getName(), attributeInfo); for (Iterator i = source.getOperations().iterator(); i.hasNext();) { GOperationInfo operationInfo = (GOperationInfo) i.next(); operations.put(new GOperationSignature(operationInfo.getName(), operationInfo.getParameterList()), operationInfo); for (Iterator iterator = source.getReferences().iterator(); iterator.hasNext();) { GReferenceInfo referenceInfo = (GReferenceInfo) iterator.next(); references.put(referenceInfo.getName(), new RefInfo(referenceInfo.getReferenceType(), referenceInfo.getNameTypeName())); for (Iterator iterator = source.getInterfaces().iterator(); iterator.hasNext();) { String intf = (String) iterator.next(); interfaces.add(intf); constructor = source.getConstructor(); priority = source.getPriority(); this.j2eeType = source.getJ2eeType(); } else { this.j2eeType = DEFAULT_J2EE_TYPE; //NameFactory.GERONIMO_SERVICE
public static LinkedHashSet<String> getImports(List<GBeanData> gbeans) { LinkedHashSet<String> imports = new LinkedHashSet<String>(); for (GBeanData data: gbeans) { GBeanInfo info = data.getGBeanInfo(); addImport(imports, info.getClassName()); for (GAttributeInfo attInfo: info.getAttributes()) { addImport(imports, attInfo.getType()); } for (GReferenceInfo refInfo: info.getReferences()) { addImport(imports, refInfo.getReferenceType()); } for (GOperationInfo opInfo: info.getOperations()) { addImport(imports, opInfo.getReturnType()); for (String paramType : opInfo.getParameterList()) { addImport(imports, paramType); } } } return imports; }
private void setDynamicGBeanDataAttributes(GBeanData gbeanData, GerConfigPropertySettingType[] configProperties, Bundle bundle) throws DeploymentException { List<String> unknownNames = new ArrayList<String>(); for (GerConfigPropertySettingType configProperty : configProperties) { String name = configProperty.getName(); GAttributeInfo attributeInfo = gbeanData.getGBeanInfo().getAttribute(name); if (attributeInfo == null) { String originalName = name; name = switchCase(name); attributeInfo = gbeanData.getGBeanInfo().getAttribute(name); if (attributeInfo == null) { unknownNames.add(originalName); continue; } } String type = attributeInfo.getType(); gbeanData.setAttribute(name, getValue(type, configProperty.getStringValue().trim(), bundle)); } if (unknownNames.size() > 0) { StringBuilder buf = new StringBuilder("The plan is trying to set attributes: ").append(unknownNames).append("\n"); buf.append("Known attributes: \n"); for (GAttributeInfo attributeInfo : gbeanData.getGBeanInfo().getAttributes()) { buf.append(attributeInfo).append("\n"); } throw new DeploymentException(buf.toString()); } }
GBeanInfo info = kernel.getGBeanInfo(connectorName); boolean found = false; Set intfs = info.getInterfaces(); for (Iterator it = intfs.iterator(); it.hasNext() && !found;) { String intf = (String) it.next(); throw new GBeanNotFoundException(connectorName); String searchingFor = info.getName(); for (Entry<ConnectorType, GBeanInfo> entry : CONNECTOR_GBEAN_INFOS.entrySet() ) { String candidate = entry.getValue().getName(); if (candidate.equals(searchingFor)) { return entry.getKey();
/** * Return MBean basic info */ @RemoteMethod public Collection<String[]> getMBeanInfo(String abstractName) { Collection<String[]> info = new ArrayList<String[]>(); try { AbstractName aname = new AbstractName(URI.create(abstractName)); info.add(new String[] { "abstractName", aname.toString() }); ObjectName oname = aname.getObjectName(); info.add(new String[] { "objectName", oname.toString() }); GBeanInfo beanInfo = kernel.getGBeanInfo(aname); String className = beanInfo.getClassName(); info.add(new String[] { "className", className }); String domain = oname.getDomain(); info.add(new String[] { "domain", domain }); String j2eeType = beanInfo.getJ2eeType(); info.add(new String[] { "j2eeType", j2eeType }); // String sourceClass = beanInfo.getSourceClass(); // info.add(new String[] { "sourceClass", sourceClass }); } catch (Exception e) { // GBean not found, just ignore } return info; }
type = classLoader.loadClass(gbeanInfo.getClassName()); } catch (ClassNotFoundException e) { throw new InvalidConfigurationException("Could not load GBeanInfo class from classloader: " + classLoader + " className=" + gbeanInfo.getClassName(), e); name = gbeanInfo.getName(); Set constructorArgs = new HashSet(gbeanInfo.getConstructor().getAttributeNames()); interfaces = (String[]) gbeanInfo.getInterfaces().toArray(new String[0]); for (Iterator iterator = gbeanInfo.getAttributes().iterator(); iterator.hasNext();) { GAttributeInfo attributeInfo = (GAttributeInfo) iterator.next(); attributesMap.put(attributeInfo.getName(), new GBeanAttribute(this, attributeInfo, constructorArgs.contains(attributeInfo.getName()))); for (Iterator iterator = gbeanInfo.getReferences().iterator(); iterator.hasNext();) { GReferenceInfo referenceInfo = (GReferenceInfo) iterator.next(); String referenceName = referenceInfo.getName(); for (Iterator iterator = gbeanInfo.getOperations().iterator(); iterator.hasNext();) { GOperationInfo operationInfo = (GOperationInfo) iterator.next(); GOperationSignature signature = new GOperationSignature(operationInfo.getName(), operationInfo.getParameterList()); List arguments = gbeanInfo.getConstructor().getAttributeNames(); Class[] parameterTypes = new Class[arguments.size()]; for (int i = 0; i < parameterTypes.length; i++) { constructor = type.getConstructor(parameterTypes); } catch (NoSuchMethodException e) {
Set attributeInfos = info.getAttributes(); Set attributeNames = new HashSet(attributeInfos.size()); for (Iterator iterator = attributeInfos.iterator(); iterator.hasNext();) { Set operationInfos = info.getOperations(); Set operationSignatures = new HashSet(operationInfos.size()); for (Iterator iterator = operationInfos.iterator(); iterator.hasNext();) {
public Set listGBeans(AbstractNameQuery query) { Map clone; synchronized (this) { clone = new HashMap(infoRegistry); } Set result = new HashSet(clone.size()); for (Iterator i = clone.entrySet().iterator(); i.hasNext();) { Map.Entry entry = (Map.Entry) i.next(); AbstractName abstractName = (AbstractName) entry.getKey(); GBeanInstance gbeanData = (GBeanInstance) entry.getValue(); if (query == null || query.matches(abstractName, gbeanData.getGBeanInfo().getInterfaces())) { result.add(gbeanData); } } return result; }
public GBeanData addGBean(String name, GBeanInfo gbeanInfo, Naming naming, Environment environment) { if (gbeanState != null) { throw new IllegalStateException("GBeans have been serialized, so no more GBeans can be added"); } String j2eeType = gbeanInfo.getJ2eeType(); if (j2eeType == null) j2eeType = "GBean"; AbstractName abstractName = naming.createRootName(environment.getConfigId(), name, j2eeType); GBeanData gBeanData = new GBeanData(abstractName, gbeanInfo); addGBean(gBeanData); return gBeanData; }
private void addContainerInfos(Configuration configuration, ContainerSystemInfo containerSystem, ConfigurationFactory configurationFactory) throws OpenEJBException { LinkedHashSet<GBeanData> containerDatas = configuration.findGBeanDatas(Collections.singleton(new AbstractNameQuery(EjbContainer.class.getName()))); for (GBeanData containerData : containerDatas) { String id = EjbContainer.getId(containerData.getAbstractName()); Class<? extends ContainerInfo> infoClass = EjbContainer.getInfoType(containerData.getGBeanInfo().getClassName()); Properties declaredProperties = new Properties(); String providerId = null; ContainerInfo containerInfo = configurationFactory.configureService(infoClass, id, declaredProperties, providerId, "Container"); containerSystem.containers.add(containerInfo); } }
/** * Return MBean attributes */ @RemoteMethod public Collection<Map<String, String>> getAttributes(String abstractNameString) { Map<String, Map<String, String>> attributes = new TreeMap<String, Map<String, String>>(); try { AbstractName abstractName = new AbstractName(URI.create(abstractNameString)); GBeanInfo gBeanInfo = kernel.getGBeanInfo(abstractName); Set<GAttributeInfo> attrs = gBeanInfo.getAttributes(); for (Iterator<GAttributeInfo> i = attrs.iterator(); i.hasNext();) { GAttributeInfo gAttrInfo = i.next(); String attrName = gAttrInfo.getName(); if (!GBEANINFO_ATTRIB.equals(attrName)) { // Don't include the 'GBeanInfo' attributes Map<String, String> attrInfoMap = getAttrInfoAsMap(abstractName, gAttrInfo); attributes.put(attrName, attrInfoMap); } } } catch (GBeanNotFoundException e) { // GBean not found, just ignore } return attributes.values(); }
GReferenceInfo referenceInfo = gbeanData.getGBeanInfo().getReference(referenceName); if (referenceInfo == null) { throw new InvalidConfigException("No reference named " + referenceName + " in gbean " + gbeanData.getAbstractName()); GAttributeInfo attribute = gbeanData.getGBeanInfo().getAttribute("configurationBaseUrl"); if (attribute != null && attribute.getType().equals("java.net.URL")) { try {
public void setXmlAttribute(String name, XmlObject xmlObject, XmlObject enclosing) throws DeploymentException { String namespace = xmlObject.getDomNode().getNamespaceURI(); XmlAttributeBuilder builder = (XmlAttributeBuilder) xmlAttributeBuilderMap.get(namespace); if (builder == null) { throw new DeploymentException("No attribute builder deployed for namespace: " + namespace); } GAttributeInfo attribute = gbean.getGBeanInfo().getAttribute(name); if (attribute == null) { throw new DeploymentException("Unknown attribute " + name + " on " + gbean.getAbstractName()); } String type = attribute.getType(); Object value = builder.getValue(xmlObject, enclosing, type, bundle); gbean.setAttribute(name, value); }
public String getGBeanDescription(AbstractName abstractName) { try { return kernel.getGBeanInfo(abstractName).getName(); } catch (GBeanNotFoundException e) { return null; } }
private String verifyReference(GBeanData gbean, String referenceName, ReferencePatterns referencePatterns, Configuration configuration) { GReferenceInfo referenceInfo = gbean.getGBeanInfo().getReference(referenceName); // if there is no reference info we can't verify if (referenceInfo == null) return null; // A collection valued reference doesn't need to be verified if (referenceInfo.getProxyType().equals(Collection.class.getName())) return null; String message = isVerifyReference(referencePatterns, configuration); if (message != null) { return "Unable to resolve reference \"" + referenceName + "\"\n" + " in gbean " + gbean.getAbstractName() + "\n to a gbean matching the pattern " + referencePatterns.getPatterns() + "\n due to: " + message; } return null; }
/** * Return MBean operations */ @RemoteMethod public Collection<Map<String, Object>> getOperations(String abstractName) { Map<String, Map<String, Object>> operations = new TreeMap<String, Map<String, Object>>(); try { AbstractName aname = new AbstractName(URI.create(abstractName)); GBeanInfo gBeaninfo = kernel.getGBeanInfo(aname); Set<GOperationInfo> opers = gBeaninfo.getOperations(); for (Iterator<GOperationInfo> i = opers.iterator(); i.hasNext();) { GOperationInfo operInfo = i.next(); Map<String, Object> operInfoMap = getOperInfoAsMap(operInfo); String operName = (String) operInfoMap.get("name"); operations.put(operName, operInfoMap); } } catch (Exception e) { // GBean not found, just ignore } return operations.values(); }
private AbstractNameQuery buildAbstractNameQuery(String refName, PatternType pattern) throws DeploymentException { // if (refName == null) { // throw new DeploymentException("No type specified in dependency pattern " + pattern + " for gbean " + gbean.getName()); // } assert refName != null; GReferenceInfo referenceInfo = null; Set referenceInfos = gbean.getGBeanInfo().getReferences(); for (Iterator iterator = referenceInfos.iterator(); iterator.hasNext();) { GReferenceInfo testReferenceInfo = (GReferenceInfo) iterator.next(); String testRefName = testReferenceInfo.getName(); if (testRefName.equals(refName)) { referenceInfo = testReferenceInfo; } } if (referenceInfo == null) { throw new DeploymentException("No reference named " + refName + " in gbean " + gbean.getAbstractName()); } return buildAbstractNameQuery(pattern, referenceInfo); }
public Set listGBeansByInterface(String[] interfaces) { Set gbeans = new HashSet(); Set all = listGBeans((AbstractNameQuery)null); for (Iterator it = all.iterator(); it.hasNext();) { AbstractName name = (AbstractName) it.next(); try { GBeanInfo info = getGBeanInfo(name); Set intfs = info.getInterfaces(); for (int i = 0; i < interfaces.length; i++) { String candidate = interfaces[i]; if(intfs.contains(candidate)) { gbeans.add(name); break; } } } catch (GBeanNotFoundException e) {} } return gbeans; }
public GBeanData addGBean(String name, GBeanInfo gbeanInfo, Naming naming, Environment environment) { if (gbeanState != null) { throw new IllegalStateException("GBeans have been serialized, so no more GBeans can be added"); } String j2eeType = gbeanInfo.getJ2eeType(); if (j2eeType == null) j2eeType = "GBean"; AbstractName abstractName = naming.createRootName(environment.getConfigId(), name, j2eeType); GBeanData gBeanData = new GBeanData(abstractName, gbeanInfo); addGBean(gBeanData); return gBeanData; }
abstractName = (AbstractName) in.readObject(); } catch (IOException e) { throw (IOException) new IOException("Unable to deserialize AbstractName for GBeanData of type " + gbeanInfo.getClassName()).initCause(e);