/** implemented. */ public void test_propertyNames() { th.checkPoint("propertyNames()java.util.Enumeration"); Properties p = new Properties(); try { p.load(bin); } catch (Exception e) { } Enumeration en = p.propertyNames(); Enumeration ek = p.keys(); boolean ok = true; Vector v = new Vector(); Enumeration ek2 = p.keys(); while (ek2.hasMoreElements()) { v.add(ek2.nextElement()); } while (ek.hasMoreElements() && en.hasMoreElements()) { ek.nextElement(); Object next = en.nextElement(); if (!v.contains(next)) { ok = false; th.debug(next + " not in " + v); } } th.check(ok, "all elements are the same"); th.check( !ek.hasMoreElements() && !en.hasMoreElements(), "make sure both enumerations are empty"); p = new Properties(defProps); resetStreams(); try { p.load(bin); } catch (Exception e) { } v.add("Smart"); v.add("animal"); en = p.propertyNames(); ok = true; Object o; while (en.hasMoreElements()) { o = en.nextElement(); if (v.contains(o)) v.removeElement(o); else { ok = false; th.debug("got extra element: " + o); } } th.check(ok, "see if no double were generated"); th.check(v.isEmpty(), "check if all names were mentioned -- got:" + v); }
public Map getSystemProperties() { Map map = new HashMap(); Properties props = System.getProperties(); for (Enumeration e = props.keys(); e.hasMoreElements(); ) { String key = (String) e.nextElement(); String val = (String) props.get(key); map.put(key, val); } return map; }
String hasProp(String prop, Properties p) { if (p == null) return null; Enumeration e = p.keys(); while (e.hasMoreElements()) { String key = (String) e.nextElement(); String val = p.getProperty(key); if (key.equalsIgnoreCase(prop)) { return val; } } return null; }
/** {@inheritDoc} */ public SynapseConfiguration createSynapseConfiguration() { String synapseXMLLocation = serverConfigurationInformation.getSynapseXMLLocation(); Properties properties = SynapsePropertiesLoader.loadSynapseProperties(); if (serverConfigurationInformation.getResolveRoot() != null) { properties.put( SynapseConstants.RESOLVE_ROOT, serverConfigurationInformation.getResolveRoot()); } if (serverConfigurationInformation.getSynapseHome() != null) { properties.put( SynapseConstants.SYNAPSE_HOME, serverConfigurationInformation.getSynapseHome()); } if (synapseXMLLocation != null) { synapseConfiguration = SynapseConfigurationBuilder.getConfiguration(synapseXMLLocation, properties); } else { log.warn( "System property or init-parameter '" + SynapseConstants.SYNAPSE_XML + "' is not specified. Using default configuration.."); synapseConfiguration = SynapseConfigurationBuilder.getDefaultConfiguration(); } Enumeration keys = properties.keys(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); synapseConfiguration.setProperty(key, properties.getProperty(key)); } // Set the Axis2 ConfigurationContext to the SynapseConfiguration synapseConfiguration.setAxisConfiguration(configurationContext.getAxisConfiguration()); MessageContextCreatorForAxis2.setSynConfig(synapseConfiguration); // set the Synapse configuration into the Axis2 configuration Parameter synapseConfigurationParameter = new Parameter(SynapseConstants.SYNAPSE_CONFIG, synapseConfiguration); try { configurationContext.getAxisConfiguration().addParameter(synapseConfigurationParameter); } catch (AxisFault e) { handleFatal( "Could not set parameters '" + SynapseConstants.SYNAPSE_CONFIG + "' to the Axis2 configuration : " + e.getMessage(), e); } addServerIPAndHostEntries(); return synapseConfiguration; }
private static int getMaxLength(Properties props) { Enumeration<Object> keys = props.keys(); int maxLength = -1; while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); if (maxLength < 0) { maxLength = key.getBytes().length; } else if (maxLength < key.getBytes().length) { maxLength = key.getBytes().length; } } return maxLength; }
private static void print(StringBuilder builder, Properties props) { int maxLength = getMaxLength(props); Enumeration<Object> keys = props.keys(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); String value = props.getProperty(key); builder .append(" ") .append(key) .append(getCharacter(maxLength - key.getBytes().length, " ")) .append(" : ") .append(value) .append("\n"); } }
public void testInvalid() { Enumeration e = invalidRsls.keys(); String key; String rsl; while (e.hasMoreElements()) { key = (String) e.nextElement(); rsl = invalidRsls.getProperty(key); System.out.println("Parsing invalid rsl " + key + ": " + rsl); try { RslNode tree = RSLParser.parse(rsl); fail("Failed to catch parse error of " + rsl); } catch (Exception ex) { } } }
public void testValid() { Enumeration e = validRsls.keys(); String key; String rsl; while (e.hasMoreElements()) { key = (String) e.nextElement(); rsl = validRsls.getProperty(key); System.out.println("Parsing valid rsl " + key + ": " + rsl); try { RSLParser.parse(rsl); } catch (Exception ex) { ex.printStackTrace(); fail("Failed to parse!!!"); } } }
/** * This method is used to get the String that contain key value pair from the propertise. * * @param String * @return String. */ public String list(String propfile) { Properties properties = (Properties) cachedPropertyFiles.get(propfile); if (properties == null) return ""; synchronized (properties) { StringBuffer buf = new StringBuffer(properties.size() * 50); for (Enumeration e = properties.keys(); e.hasMoreElements(); ) { String key = (String) e.nextElement(); String val = (String) properties.get(key); if (val.length() > 40) { val = val.substring(0, 37) + "..."; } buf.append(key); buf.append('='); buf.append(val); buf.append('\n'); } return buf.toString(); } }
/** this test will check if all forms lines are accepted in the load. */ public void test_loadextra() { th.checkPoint("load(java.io.InputStream)void"); Properties p = new Properties(); buffer = new String( " !comment\n \t \nname = no\r #morec\tomm\\\nents\r\n dog=no\\\\cat \nburps :\ntest=\ndate today\n\n\nlong\\\n value=tryin \\\n gto\n4:vier\nvier :4") .getBytes(); bin = new ByteArrayInputStream(buffer); try { p.load(bin); } catch (Exception e) { } Enumeration e = p.keys(); Vector v = new Vector(); // Note that there used to be code here checking whether the // "!comment" and "#morec" keys were found, on the theory that // leading whitespace mattered. This no longer seems to be the // case, however. In the past it apparently varied between JVMs, // but the 1.4 docs are unambiguous on this topic. We check for // "ents" since line-continuation doesn't affect comments. v.add("ents="); v.add("name=no"); v.add("dog=no\\cat "); v.add("burps="); v.add("test="); v.add("date=today"); v.add("longvalue=tryin gto"); v.add("4=vier"); v.add("vier=4"); String s; while (e.hasMoreElements()) { s = (String) e.nextElement(); th.debug("checkvalue -- got:$" + s + "=" + p.getProperty(s) + "$"); th.check( v.contains(s + "=" + p.getProperty(s)), "checkvalue -- got:$" + s + "=" + p.getProperty(s) + "$"); v.removeElement(s + "=" + p.getProperty(s)); } th.check(v.isEmpty(), "check if all elements were found -- got: " + v); }
public Map<String, HGLocation> getLocationList(String prefix) throws NumberFormatException, UnsupportedEncodingException { // iterate over props looking for keys that start with loc. Map<String, HGLocation> locations = new HashMap<String, HGLocation>(); // HashSet<HGLocation> locations = new HashSet<HGLocation>(); for (Enumeration<Object> e = worldlyProperties.keys(); e.hasMoreElements(); /**/ ) { String key = (String) e.nextElement(); // String value = worldlyProperties.getProperty(key); // System.out.println(key + " = " + value); // Iterator<Object> iter = worldlyProperties.keySet().iterator(); // for (String key = null; iter.hasNext(); key = (String) iter.next()) { if (key.startsWith(prefix)) { // populate locations String locArgs = worldlyProperties.getProperty(key); if (locArgs != null && !locArgs.isEmpty()) { String[] parts = locArgs.split(","); if (parts.length == 9) { HGLocation location = new HGLocation( URLDecoder.decode(parts[0], HGStatics.UTF8), // playername URLDecoder.decode(parts[1], HGStatics.UTF8), // locationname URLDecoder.decode(parts[2], HGStatics.UTF8), // worldname Integer.parseInt(URLDecoder.decode(parts[3], HGStatics.UTF8)), // x Integer.parseInt(URLDecoder.decode(parts[4], HGStatics.UTF8)), // y Integer.parseInt(URLDecoder.decode(parts[5], HGStatics.UTF8)), // z Float.parseFloat(URLDecoder.decode(parts[6], HGStatics.UTF8)), // pitch Float.parseFloat(URLDecoder.decode(parts[7], HGStatics.UTF8)), // yaw Long.parseLong(URLDecoder.decode(parts[8], HGStatics.UTF8))); locations.put(parts[0] + parts[1], location); } } } } return locations; }
/** * Loads the installation data. Also sets environment variables to <code>installdata</code>. All * system properties are available as $SYSTEM_<variable> where <variable> is the actual name _BUT_ * with all separators replaced by '_'. Properties with null values are never stored. Example: * $SYSTEM_java_version or $SYSTEM_os_name * * @param installdata Where to store the installation data. * @throws Exception Description of the Exception */ public void loadInstallData(AutomatedInstallData installdata) throws Exception { // Usefull variables InputStream in; ObjectInputStream objIn; int size; int i; // We load the variables Properties variables = null; in = InstallerBase.class.getResourceAsStream("/vars"); if (null != in) { objIn = new ObjectInputStream(in); variables = (Properties) objIn.readObject(); objIn.close(); } // We load the Info data in = InstallerBase.class.getResourceAsStream("/info"); objIn = new ObjectInputStream(in); Info inf = (Info) objIn.readObject(); objIn.close(); // We put the Info data as variables installdata.setVariable(ScriptParser.APP_NAME, inf.getAppName()); if (inf.getAppURL() != null) { installdata.setVariable(ScriptParser.APP_URL, inf.getAppURL()); } installdata.setVariable(ScriptParser.APP_VER, inf.getAppVersion()); if (inf.getUninstallerCondition() != null) { installdata.setVariable("UNINSTALLER_CONDITION", inf.getUninstallerCondition()); } // We read the panels order data in = InstallerBase.class.getResourceAsStream("/panelsOrder"); objIn = new ObjectInputStream(in); List panelsOrder = (List) objIn.readObject(); objIn.close(); // We read the packs data in = InstallerBase.class.getResourceAsStream("/packs.info"); objIn = new ObjectInputStream(in); size = objIn.readInt(); ArrayList availablePacks = new ArrayList(); ArrayList<Pack> allPacks = new ArrayList<Pack>(); for (i = 0; i < size; i++) { Pack pk = (Pack) objIn.readObject(); allPacks.add(pk); if (OsConstraint.oneMatchesCurrentSystem(pk.osConstraints)) { availablePacks.add(pk); } } objIn.close(); // We determine the operating system and the initial installation path String dir; String installPath; if (OsVersion.IS_WINDOWS) { dir = buildWindowsDefaultPath(); } else if (OsVersion.IS_OSX) { dir = "/Applications"; } else { if (new File("/usr/local/").canWrite()) { dir = "/usr/local"; } else { dir = System.getProperty("user.home"); } } // We determine the hostname and IPAdress String hostname; String IPAddress; try { InetAddress addr = InetAddress.getLocalHost(); // Get IP Address IPAddress = addr.getHostAddress(); // Get hostname hostname = addr.getHostName(); } catch (Exception e) { hostname = ""; IPAddress = ""; } installdata.setVariable("APPLICATIONS_DEFAULT_ROOT", dir); dir += File.separator; installdata.setVariable(ScriptParser.JAVA_HOME, System.getProperty("java.home")); installdata.setVariable(ScriptParser.CLASS_PATH, System.getProperty("java.class.path")); installdata.setVariable(ScriptParser.USER_HOME, System.getProperty("user.home")); installdata.setVariable(ScriptParser.USER_NAME, System.getProperty("user.name")); installdata.setVariable(ScriptParser.IP_ADDRESS, IPAddress); installdata.setVariable(ScriptParser.HOST_NAME, hostname); installdata.setVariable(ScriptParser.FILE_SEPARATOR, File.separator); Enumeration e = System.getProperties().keys(); while (e.hasMoreElements()) { String varName = (String) e.nextElement(); String varValue = System.getProperty(varName); if (varValue != null) { varName = varName.replace('.', '_'); installdata.setVariable("SYSTEM_" + varName, varValue); } } if (null != variables) { Enumeration enumeration = variables.keys(); String varName; String varValue; while (enumeration.hasMoreElements()) { varName = (String) enumeration.nextElement(); varValue = variables.getProperty(varName); installdata.setVariable(varName, varValue); } } installdata.info = inf; installdata.panelsOrder = panelsOrder; installdata.availablePacks = availablePacks; installdata.allPacks = allPacks; // get list of preselected packs Iterator pack_it = availablePacks.iterator(); while (pack_it.hasNext()) { Pack pack = (Pack) pack_it.next(); if (pack.preselected) { installdata.selectedPacks.add(pack); } } // Set the installation path in a default manner installPath = dir + inf.getAppName(); if (inf.getInstallationSubPath() != null) { // A subpath was defined, use it. installPath = IoHelper.translatePath( dir + inf.getInstallationSubPath(), new VariableSubstitutor(installdata.getVariables())); } installdata.setInstallPath(installPath); // Load custom action data. loadCustomData(installdata); }
/** * implemented. <br> * Add a test to determine of store generates a comment line with the current time <br> * <br> * depricated method !!! */ public void test_save() { th.checkPoint("save(java.io.OutputStream,java.lang.String)void"); Properties p = new Properties(defProps); try { p.save(null, "no comment"); th.fail("should throw NullPointerException"); } catch (NullPointerException ne) { th.check(true); } catch (Exception e) { th.fail("should throw an NullPointerEception instead of: " + e); } try { p.save(bout, null); th.check(true); } catch (NullPointerException ne) { th.fail("should not throw NullPointerException"); } catch (Exception e) { th.fail("shouldn't throw any Exception, but got: " + e); } resetStreams(); try { p.save(bout, null); } catch (Exception e) { th.fail("shouldn't throw any Exception, but got: " + e); } byte ba[] = bout.toByteArray(); th.check((ba[0] == (byte) '#') && (ba[1] != (byte) '#'), "just date should be written"); th.debug(ba.length + " -- got: " + new String(ba)); th.check(ba.length < 50, "default properties are never printed out"); resetStreams(); try { p.load(bin); } catch (Exception e) { } try { p.save(bout, "no comments"); } catch (Exception e) { th.fail("shouldn't throw any Exception, but got: " + e); } ba = bout.toByteArray(); String s = new String(ba, 0, 12); th.check(s.equals("#no comments"), "got: " + s); int i = 0, count = 0; while (i < 2 && count < ba.length) { if (ba[count++] == (byte) '\n') i++; } // we will construct a vector containing all the lines with should be written Vector v = new Vector(); Enumeration ek = p.keys(); while (ek.hasMoreElements()) { s = (String) ek.nextElement(); v.add(s + "=" + p.getProperty(s)); } while (count < ba.length) { int start = count; while (count < ba.length) { if (ba[count] != '\n') count++; else break; } s = new String(ba, start, count - start); th.check(v.contains(s), "v does not contain: " + s); v.removeElement(s); count++; } }
public void doGeneric(String method, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { try { startTransaction(request.getHeader("User-Agent")); // Marshal Jetty request parameters to Nano-style. // Note that getServletPath does an un-escape so that the %24 of job id's are turned into $ // characters. String uri = request.getServletPath(); Properties headers = new Properties(); Enumeration<String> en = request.getHeaderNames(); while (en.hasMoreElements()) { String key = en.nextElement(); String value = request.getHeader(key); headers.put(key, value); } Properties parms = new Properties(); Map<String, String[]> parameterMap; parameterMap = request.getParameterMap(); for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) { String key = entry.getKey(); String[] values = entry.getValue(); for (String value : values) { parms.put(key, value); } } // Make Nano call. NanoHTTPD.Response resp = water.api.RequestServer.SERVER.serve(uri, method, headers, parms); // Un-marshal Nano response back to Jetty. String choppedNanoStatus = resp.status.substring(0, 3); assert (choppedNanoStatus.length() == 3); int sc = Integer.parseInt(choppedNanoStatus); setResponseStatus(response, sc); response.setContentType(resp.mimeType); Properties header = resp.header; Enumeration<Object> en2 = header.keys(); while (en2.hasMoreElements()) { String key = (String) en2.nextElement(); String value = header.getProperty(key); response.setHeader(key, value); } OutputStream os = response.getOutputStream(); if (resp instanceof NanoHTTPD.StreamResponse) { NanoHTTPD.StreamResponse ssr = (NanoHTTPD.StreamResponse) resp; ssr.streamWriter.writeTo(os); } else { InputStream is = resp.data; FileUtils.copyStream(is, os, 1024); } } finally { logRequest(method, request, response); // Handle shutdown if it was requested. if (H2O.getShutdownRequested()) { (new Thread() { public void run() { boolean[] confirmations = new boolean[H2O.CLOUD.size()]; if (H2O.SELF.index() >= 0) { confirmations[H2O.SELF.index()] = true; } for (H2ONode n : H2O.CLOUD._memary) { if (n != H2O.SELF) new RPC(n, new ShutdownTsk(H2O.SELF, n.index(), 1000, confirmations)).call(); } try { Thread.sleep(2000); } catch (Exception ignore) { } int failedToShutdown = 0; // shutdown failed for (boolean b : confirmations) if (!b) failedToShutdown++; Log.info( "Orderly shutdown: " + (failedToShutdown > 0 ? failedToShutdown + " nodes failed to shut down! " : "") + " Shutting down now."); H2O.closeAll(); H2O.exit(failedToShutdown); } }) .start(); } endTransaction(); } }
/** * implemented. <br> * load is used by other tests to make a propeties file <br> * failures in load will mak other tests fail ! */ public void test_load() { th.checkPoint("load(java.io.InputStream)void"); Properties p = new Properties(); try { p.load((ByteArrayInputStream) null); th.fail("should throw NullPointerException"); } catch (NullPointerException ne) { th.check(true); } catch (Exception e) { th.fail("should throw an NullPointerException instead of: " + e); } try { p.load(bin); } catch (Exception e) { } Enumeration ek1 = p.keys(); resetStreams(); try { p.load(bin); } catch (Exception e) { } Enumeration ek2 = p.keys(); boolean ok = true; while (ek1.hasMoreElements() && ek2.hasMoreElements()) { if (ek1.nextElement() != ek2.nextElement()) ok = false; } th.check( !ek1.hasMoreElements() && !ek2.hasMoreElements(), "no extra elements may be added with same name"); th.check(ok, " all elements are equal "); bin = new ByteArrayInputStream(new String("name=yes\nSmart=move\nanimal=dog").getBytes()); try { p.load(bin); } catch (Exception e) { } th.check(p.getProperty("name").equals("yes"), "load overrides previous values"); Vector v = new Vector(); v.add("name"); v.add("Smart"); v.add("animal"); v.add("dog"); v.add("test"); v.add("date"); v.add("longvalue"); v.add("40chars"); ek1 = p.keys(); ok = true; Object o; while (ek1.hasMoreElements()) { o = ek1.nextElement(); if (v.contains(o)) v.removeElement(o); else { ok = false; th.debug("got extra element: " + (String) o); } } th.check(ok, "all elements were there"); th.check(v.isEmpty(), "all elements should be gone, got" + v); setUpTest(); }
/** implemented. */ public void test_list() { th.checkPoint("list(java.io.PrintStream)void"); Properties p = new Properties(); try { p.list((PrintStream) null); th.fail("should throw NullPointerException -- 1"); } catch (NullPointerException ne) { th.check(true); } try { p.load(bin); } catch (Exception e) { } p.list(psout); byte ba[] = bout.toByteArray(); Vector v = new Vector(); Enumeration ek = p.keys(); String s; while (ek.hasMoreElements()) { s = (String) ek.nextElement(); v.add(s + "=" + p.getProperty(s)); } v.add("Smart=move"); v.add("animal=dog"); int start, count = 0; v.removeElement("longvalue=I'mtryingtogiveavaluelongerthen40characters"); v.add("longvalue=I'mtryingtogiveavaluelongerthen40char..."); while (count < ba.length) { start = count; while (ba[count] != '\n' && count < ba.length) { count++; } s = new String(ba, start, count - start); if (!s.startsWith("--")) // list() adds a header th.check(v.contains(s), "v does not contain:$" + s + "$"); v.removeElement(s); count++; } try { p.list((PrintStream) null); th.fail("should throw NullPointerException -- 2"); } catch (NullPointerException ne) { th.check(true); } th.checkPoint("list(java.io.PrintWriter)void"); resetStreams(); p = new Properties(); try { p.list((PrintWriter) null); th.fail("should throw NullPointerException -- 1"); } catch (NullPointerException ne) { th.check(true); } try { p.load(bin); } catch (Exception e) { } p.list(pwout); ba = bout.toByteArray(); v = new Vector(); ek = p.keys(); while (ek.hasMoreElements()) { s = (String) ek.nextElement(); v.add(s + "=" + p.getProperty(s)); } v.add("Smart=move"); v.add("animal=dog"); count = 0; v.removeElement("longvalue=I'mtryingtogiveavaluelongerthen40characters"); v.add("longvalue=I'mtryingtogiveavaluelongerthen40char..."); while (count < ba.length) { start = count; while (ba[count] != '\n' && count < ba.length) { count++; } s = new String(ba, start, count - start); if (!s.startsWith("--")) // list() adds a header th.check(v.contains(s), "v does not contain:$" + s + "$"); v.removeElement(s); count++; } try { p.list((PrintStream) null); th.fail("should throw NullPointerException -- 2"); } catch (NullPointerException ne) { th.check(true); } }
/** * Construct a new MappedMessageHandler from the provided configuration. * * @param config the {@link MessageHandlerConfiguration} used to configure this instance * @throws ToolkitException rethrown from {@link * MessageHandlerConfigurationFactory#getConfiguration()}. */ public MappedMessageHandler(MessageHandlerConfiguration config) throws ToolkitException { supportedServices = new HashMap<String, NCIPService<NCIPInitiationData, NCIPResponseData>>(); Properties properties = config.getProperties(); for (Enumeration enumeration = properties.keys(); enumeration.hasMoreElements(); /**/ ) { String key = (String) enumeration.nextElement(); LOG.debug("Property key=" + key); if (key.compareToIgnoreCase("java.version") == 0) { LOG.debug("Java version is " + properties.get(key)); } if (key.matches("(?i)[A-Za-z]+Service\\.Class")) { String className = (String) properties.get(key); LOG.debug("Class name=" + className); if (className == null || className.isEmpty() || className.compareToIgnoreCase("null") == 0) { continue; } try { Class<?> clazz = Class.forName(className); Class<? extends NCIPService> xc = clazz.asSubclass(NCIPService.class); LOG.debug("Class as subclass=" + xc.getName()); try { NCIPService<NCIPInitiationData, NCIPResponseData> serviceInstance; try { Constructor<? extends NCIPService> propertiesCtor = xc.getConstructor(Properties.class); serviceInstance = propertiesCtor.newInstance(properties); } catch (NoSuchMethodException e) { serviceInstance = xc.newInstance(); } catch (InvocationTargetException e) { throw new ToolkitException( "Exception constructing " + className + " using Properties:", e); } Method[] methods = clazz.getMethods(); Class initDataClass = null; // TODO: Try replacing this with getMethod("performService", NCIPInitiationData.class, // ServiceContext.class, RemoteServiceManager.class); for (Method method : methods) { LOG.debug("Testing method " + method.getName()); if (method.getName().compareToIgnoreCase("performService") == 0) { LOG.debug("Method is performService."); Class[] parameterTypes = method.getParameterTypes(); // This assumes there will only be one performService method on any class, // i.e. the one required by the NCIPService interface definition. // While the definition of NCIPService doesn't actually enforce this, // it would be perverse to define an additional method with that name // taking similar parameter types. if (parameterTypes.length == NUMBER_OF_PARAMETERS_TO_PERFORM_SERVICE_METHOD) { LOG.debug("Method takes " + parameterTypes.length + " parameters."); Class parameterClass = parameterTypes[0]; LOG.debug("ParameterType[0] is " + parameterClass.getName()); if (parameterClass.getName().compareTo(Class.class.getName()) != 0) { initDataClass = parameterClass; if (initDataClass.getName().compareTo(Object.class.getName()) == 0) { LOG.warn( "Class first parameter is 'Object'; trying to use property key to get actual initDataClass."); String serviceName = key.substring(0, key.length() - "Service.Class".length()); initDataClass = ServiceHelper.constructInitiationDataClass(serviceName); } else { LOG.debug("The initDataClass is not 'Object'."); } LOG.debug("Selecting " + initDataClass.getName() + " as initDataClass."); break; } else { LOG.debug( "The performService method for class " + clazz.getName() + " takes a Class parameter, which is disallowed."); } } else { LOG.debug( "The performService method for class " + clazz.getName() + " has no parameters."); } } else { LOG.debug("Method is not performService."); } } LOG.debug("Finished checking methods."); if (initDataClass != null) { LOG.debug( "Putting " + serviceInstance.getClass().getName() + " into supportedServices map " + "with key of " + initDataClass.getName() + "."); supportedServices.put(initDataClass.getName(), serviceInstance); } else { throw new ToolkitException( "Unable to determine NCIPInitiationData sub-class with " + "name '" + className + "' for " + key); } } catch (InstantiationException e) { throw new ToolkitException("Exception while populating supported services.", e); } catch (IllegalAccessException e) { throw new ToolkitException("Exception while populating supported services.", e); } } catch (ClassNotFoundException e) { throw new ToolkitException( "Class not found exception while populating supported services.", e); } } else if (key.matches("(?i)RemoteServiceManager\\.Class")) { try { Class<?> clazz = Class.forName(properties.getProperty(key)); Constructor ctor = clazz.getConstructor(Properties.class); serviceManager = (RemoteServiceManager) ctor.newInstance(properties); } catch (ClassNotFoundException e) { throw new ToolkitException("Exception while populating supported services.", e); } catch (NoSuchMethodException e) { throw new ToolkitException("Exception while populating supported services.", e); } catch (InvocationTargetException e) { throw new ToolkitException("Exception while populating supported services.", e); } catch (InstantiationException e) { throw new ToolkitException("Exception while populating supported services.", e); } catch (IllegalAccessException e) { throw new ToolkitException("Exception while populating supported services.", e); } } } LOG.debug("Finished with properties."); if (LOG.isDebugEnabled()) { LOG.debug("Service map for " + this + ":"); for (Map.Entry<String, NCIPService<NCIPInitiationData, NCIPResponseData>> entry : supportedServices.entrySet()) { LOG.debug(entry.getKey() + "=" + entry.getValue()); } } }