Пример #1
0
void Element::validateNs()
{
	if(nameSpace=="" || isValidNamespace(this, nameSpace))
	{
		ElementList elements = this->getChildElements();
		for(unsigned int i=0;i<elements.size();i++)
		{
			elements.at(i).parent = this;
			elements.at(i).validateNs();
		}
	}
	else
	{
		throw ("No namespace definition found - xmlns:" + nameSpace);
	}
}
Пример #2
0
string Element::renderChildren()
{
	string rend;
	ElementList elements = this->getChildElements();
	for(unsigned int i=0;i<elements.size();i++)
	{
		rend.append(elements.at(i).render());
	}
	return rend;
}
Пример #3
0
void View::traverseElement(string *ss, Element* element)
{
	ss->append(generateStartOpenTag(element->getTagName()));
	ss->append(generateAttributes(element->getAttributes()));
	ss->append(generateEndOpenTag());
	ss->append(element->getText());
	ElementList elements = element->getChildElements();
	for(unsigned int i=0;i<elements.size();i++)
	{
		traverseElement(ss, elements.at(i));
	}
	ss->append(generateCloseTag(element->getTagName()));
}
Пример #4
0
std::string Document::render()
{
	std::string rend = this->docType;
	rend.append(generateStartOpenTag(this->root.getTagName()));
	rend.append(generateAttributes(this->root.getAttributes()));
	rend.append(generateEndOpenTag());
	rend.append(this->root.getText());
	ElementList elements = this->root.getChildElements();
	for(unsigned int i=0;i<elements.size();i++)
	{
		rend.append(elements.at(i)->render());
	}
	rend.append(generateCloseTag(this->root.getTagName()));
	return rend;
}
Пример #5
0
string Element::render()
{
	string rend;
	rend.append(generateStartOpenTag(this->getTagName()));
	rend.append(generateAttributes(this->getAttributes()));
	//rend.append(generateAttributes(this->namespaces));
	rend.append(generateEndOpenTag());
	rend.append(this->getText());
	ElementList elements = this->getChildElements();
	for(unsigned int i=0;i<elements.size();i++)
	{
		rend.append(elements.at(i).render());
	}
	rend.append(generateCloseTag(this->getTagName()));
	return rend;
}
Пример #6
0
string Element::renderSerialization()
{
	string rend;
	rend.append(generateStartOpenTag(this->getTagName()));
	rend.append(generateAttributes(this->getAttributes()));
	//rend.append(" namespace=\""+getNameSpcValue()+"\"");
	rend.append(generateEndOpenTag());
	rend.append(this->getText());
	ElementList elements = this->getChildElements();
	for(unsigned int i=0;i<elements.size();i++)
	{
		rend.append(elements.at(i)->renderSerialization());
	}
	rend.append(generateCloseTag(this->getTagName()));
	return rend;
}
Пример #7
0
Element* Document::getElementByName(const std::string& name, Element* ele)
{
	if(ele->getTagName()==name)
		return ele;
	else
	{
		ElementList chi = ele->getChildElements();
		for(unsigned int i=0;i<chi.size();i++)
		{
			Element* ele1 = getElementByName(name, chi.at(i));
			if(ele1!=NULL)
			{
				return ele1;
			}
		}
	}
	return NULL;
}
Пример #8
0
std::string ApplicationUtil::buildAllApplications(const std::vector<std::string>& files, const std::vector<std::string>& apps)
{
	std::string headers = "#include \"fstream\"\n#include \"string\"\n#include \"HttpSession.h\"\n#include \"CastUtil.h\"\n\n";
	std::string code;
	std::string meth,methdef,vars;
	for (unsigned int var = 0; var < files.size(); ++var)
	{
		std::string path = files.at(var).substr(0,files.at(var).find_last_of("/")+1);
		std::string appName = apps.at(var).substr(0,apps.at(var).find_last_of("/"));

		XmlParser parser("Parser");
		Document doc;
		parser.readDocument(files.at(var), doc);
		const Element& root = doc.getRootElement();
		ElementList eles = root.getChildElements();
		if(eles.size()==0)
		{
			ConfigurationData::getInstance()->applicationFlowMap[appName] = false;
		}
		else
		{
			meth += "std::string "+appName+"checkRules(std::string to,HttpSession session)\n{\nstd::string curr=session.getAttribute(\"CURR\");\n";
			for (unsigned int var = 0; var < eles.size(); var++)
			{
				if(eles.at(var)->getTagName()=="include")
				{
					std::string inc = eles.at(var)->getText();
					strVec incs;
					StringUtil::split(incs, inc, (" "));
					for (unsigned int i = 0; i < incs.size(); i++)
					{
						headers += ("#include \"" + incs.at(i) + "\"\n");
					}
				}
				else if(eles.at(var)->getTagName()=="page" || eles.at(var)->getTagName()=="welcome")
				{
					meth += ("std::string " + eles.at(var)->getAttribute("id") + " = \""+path+eles.at(var)->getAttribute("path")+"\";\n");
					if(eles.at(var)->getAttribute("who")!="" && eles.at(var)->getAttribute("where")!="")
					{
						if(eles.at(var)->getAttribute("where").find("FILE:")!=std::string::npos)
						{
							std::string fileName = eles.at(var)->getAttribute("where");
							StringUtil::replaceFirst(fileName,"FILE:","");
							fileName = (path + fileName);
							meth += "std::string path;\nif(to=="+eles.at(var)->getAttribute("id")+")\n{";
							meth += "std::string user = session.getAttribute(\"USER\");\n";
							meth += "std::string pass = session.getAttribute(\"PASS\");\n";
							meth += "ifstream f(\""+fileName+"\");\n";
							meth += "if(f.is_open())\n{\nstd::string temp;\nwhile(getline(f,temp,'\\n'))\n{\n";
							meth += "if(temp==(user+\" \"+pass))\n{\nf.close();path = "+eles.at(var)->getAttribute("id");
							meth += ";break;}\n}\nf.close();\n}\nif(path==\"\")\npath=\"FAILED\";\n}\n";
						}
					}
					else if(eles.at(var)->getAttribute("onsuccess")!="" && eles.at(var)->getAttribute("onfail")!="")
					{

					}
				}
				else if(eles.at(var)->getTagName()=="rule")
				{
					meth += "\nif(to=="+eles.at(var)->getAttribute("topage")+" && curr=="+eles.at(var)->getAttribute("currpage")+")\n{";
					ElementList elesc = eles.at(var)->getChildElements();
					for (unsigned int var1 = 0; var1 < elesc.size(); var1++)
					{
						if(elesc.at(var1)->getTagName()=="execute")
						{
							std::string call = elesc.at(var1)->getAttribute("call");
							std::string clas = call.substr(0,call.find("."));
							std::string method = call.substr(call.find(".")+1);
							headers += ("#include \""+clas+".h\"\n");
							meth += clas + " _object;\n";
							std::string args;
							ElementList elesce = elesc.at(var1)->getChildElements();
							for (unsigned int var2 = 0; var2 < elesce.size(); var2++)
							{
								meth += (elesce.at(var2)->getTagName() + " _" + CastUtil::lexical_cast<std::string>(var2+1) + " = CastUtil::lexical_cast<"+elesce.at(var2)->getTagName()+">(\""+elesce.at(var2)->getText()+"\");\n");
								args += ("_"+CastUtil::lexical_cast<std::string>(var2+1));
								if(var2!=elesce.size()-1)
									args += ",";
							}
							if(elesc.at(var1)->getAttribute("rettype")!="" || elesc.at(var1)->getAttribute("rettype")!="void")
							{
								meth += (elesc.at(var1)->getAttribute("rettype") + " " + elesc.at(var1)->getAttribute("retname") + " = ");
								meth += "_object."+method+"("+args+");\n";
							}
						}
					}
					meth += "path=to;\n}\n";
				}
			}
			meth += "return path;}\n";
			code += methdef;
			ConfigurationData::getInstance()->applicationFlowMap[appName] = true;
		}
	}
	code += (headers + "extern \"C\"\n{\n"+vars+meth+"}\n");
	return code;

}
Пример #9
0
void* ComponentHandler::service(void* arg)
{
	int fd = *(int*)arg;
	init();
	string methInfo,retValue;
	_cmp_instance->getServer()->Receive(fd,methInfo,1024);
	methInfo =methInfo.substr(0,methInfo.find_last_of(">")+1);
	_cmp_instance->logger << methInfo << flush;
	try
	{
		XmlParser parser("Parser");
		_cmp_instance->logger << "\nBean call parsed successfully\n" << flush;
		if(methInfo.find("lang=\"c++\"")!=string::npos || methInfo.find("lang='c++'")!=string::npos)
		{
			Document doc = parser.getDocument(methInfo);
			Element message = doc.getRootElement();
			if(message.getTagName()!="service")
			{
				throw new ComponentHandlerException("No service Tag\n",retValue);
			}
			if(message.getAttributes().size()<4)
			{
				throw new ComponentHandlerException("name,beanName,returnType and lang are mandatory attributes\n",retValue);
			}
			else if(message.getAttribute("name")=="")
			{
				throw new ComponentHandlerException("name attribute missing\n",retValue);
			}
			else if(message.getAttribute("returnType")=="")
			{
				throw new ComponentHandlerException("returnType attribute missing\n",retValue);
			}
			else if(message.getAttribute("beanName")=="")
			{
				throw new ComponentHandlerException("beanName attribute missing\n",retValue);
			}
			else if(message.getAttribute("lang")=="")
			{
				throw new ComponentHandlerException("lang attribute missing\n",retValue);
			}
			if(message.getChildElements().size()!=1)
			{
				throw new ComponentHandlerException("message tag should have only one child tag\n",retValue);
			}
			else if(message.getChildElements().at(0).getTagName()!="args")
			{
				throw new ComponentHandlerException("message tag should have an args child tag\n",retValue);
			}
			Serialize ser;
			Reflector reflector;
			args argus;
			vals valus;
			ElementList argts = message.getChildElements().at(0).getChildElements();
			for (unsigned var = 0; var < argts.size();  var++)
			{
				void *value = NULL;
				Element arg = argts.at(var);
				if(arg.getTagName()!="argument")
					throw new ComponentHandlerException("Invalid Tag, only argument tag allowed\n",retValue);
				else if(arg.getAttribute("type")=="")
					throw new ComponentHandlerException("every argument tag should have a type attribute\n",retValue);
				if(arg.getText()=="" && arg.getChildElements().size()==0)
					throw new ComponentHandlerException("argument value missing\n",retValue);
				if(arg.getAttribute("type")!="")
				{
					Element obj = arg.getChildElements().at(0);
					string objxml = obj.render();
					string objClassName = obj.getTagName();
					value = ser.unSerializeUnknown(objxml,arg.getAttribute("type"));
				}
				argus.push_back(arg.getAttribute("type"));
				valus.push_back(value);
			}
			string className = "Component_"+message.getAttribute("beanName");
			_cmp_instance->logger << "\nBean class = " << className << "\n" << flush;
			string returnType = message.getAttribute("returnType");
			string lang = message.getAttribute("lang");
			ClassInfo clas = reflector.getClassInfo(className);
			string methodName = message.getAttribute("name");
			_cmp_instance->logger << "\nBean service = " << methodName << "\n" << flush;
			if(clas.getClassName()=="")
			{
				throw new ComponentHandlerException("bean does not exist or is not regsitered\n",retValue);
			}
			Method meth = clas.getMethod(methodName,argus);
			if(meth.getMethodName()=="")
			{
				throw new ComponentHandlerException("service does not exist for the bean or the bean does not exist or is not regsitered\n\n",retValue);
			}
			else
			{
				_cmp_instance->logger << "\nGot Bean service " << methodName << "\n" << flush;
				args argus;
				Constructor ctor = clas.getConstructor(argus);
				void *_temp = reflector.newInstanceGVP(ctor);
				_cmp_instance->logger << "\nGot Bean " << _temp << "\n" << flush;
				if(returnType=="void" || returnType=="")
				{
					_cmp_instance->logger << "\nVoid return " << "\n" << flush;
					reflector.invokeMethod<void*>(_temp,meth,valus);
					retValue = ("<return:void></return:void>");
				}
				else
				{
					_cmp_instance->logger << "\nReturn type = "<< returnType << "\n" << flush;
					if(returnType=="int")
					{
						int retv = reflector.invokeMethod<int>(_temp,meth,valus);
						retValue = ("<return:int>"+CastUtil::lexical_cast<string>(retv)+"</return:int>");
					}
					else if(returnType=="float")
					{
						float retv = reflector.invokeMethod<float>(_temp,meth,valus);
						retValue = ("<return:float>"+CastUtil::lexical_cast<string>(retv)+"</return:float>");
					}
					else if(returnType=="double")
					{
						double retv = reflector.invokeMethod<double>(_temp,meth,valus);
						retValue = ("<return:double>"+CastUtil::lexical_cast<string>(retv)+"</return:double>");
					}
					else if(returnType=="string")
					{
						string retv = reflector.invokeMethod<string>(_temp,meth,valus);
						retValue = ("<return:string>"+retv+"</return:string>");
					}
					else if(returnType!="")
					{
						void* retobj = reflector.invokeMethodUnknownReturn(_temp,meth,valus);
						string oxml = ser.serializeUnknown(retobj,returnType);
						retValue = ("<return:"+returnType+">"+oxml+"</return:"+returnType+">");
					}
				}

			}
		}
		else
		{
			retValue = "<return:exception>This is a C++ daemon</return:exception>";
		}
		_cmp_instance->logger << "\nSending data = "<< retValue << "\n" << flush;
		if(retValue!="")
			_cmp_instance->getServer()->Send(fd,retValue);
		//close(fd);
	}
	catch(ComponentHandlerException *e)
	{
		_cmp_instance->logger << e->getMessage() << flush;
		_cmp_instance->getServer()->Send(fd,retValue);
		close(fd);
	}
	catch(...)
	{
		_cmp_instance->logger << "exception occurred" << flush;
		retValue = ("<return:exception>XmlParseException occurred</return:exception>");
		_cmp_instance->getServer()->Send(fd,retValue);
		close(fd);
	}
}
Пример #10
0
string WsUtil::generateWSDL(string file,map<string, ClassStructure> allclsmap,string resp,string &headers,map<string,string> &wsmap,string appname,string ip_address, Reflection ref)
{
	XmlParser parser("Parser");
	Document doc = parser.getDocument(file);
	Element root = doc.getRootElement();
	typedef vector<Element> ElementList;
	typedef map<string,string> strMap;
	typedef map<string,strMap> meth_Map;
	typedef map<string,meth_Map> ws_inp_out_Map;
	ElementList wsvcs = root.getChildElements();
	if(wsvcs.size()==0)
		return "";

	string ws_funcs,obj_mapng,retObj_xml;
	for(unsigned int ii=0;ii<wsvcs.size();ii++)
	{
		ws_inp_out_Map ws_info;
		meth_Map meth_info;
		StringContext gcntxt;
		string ws_name,reqr_res_bind,wsdl_msgs,wsdl_ops,wsdl_bind,wsdl,wsdl_obj_bind;
		Element ws = wsvcs.at(ii);
		ws_name = ws.getAttribute("class");
		string ows_name = ws_name;
		StringUtil::replaceAll(ws_name, "::", "_");
		if(StringUtil::trimCopy(ws_name)=="")
		{
			logger << ("No class name defined for web-service, skipping...") << endl;
			continue;
		}
		if(StringUtil::trimCopy(ws.getAttribute("location"))=="")
		{
			logger << ("No location defined for web-service, skipping...") << endl;
			continue;
		}
		gcntxt["WS_NAME"] = ws_name;
		gcntxt["WS_PATH"] = ws.getAttribute("location");
		if(gcntxt["WS_PATH"].at(0)=='/')
		{
			gcntxt["WS_PATH"] = gcntxt["WS_PATH"].substr(1);
			StringUtil::replaceAll(gcntxt["WS_PATH"], "//", "/");
		}
		gcntxt["WS_NMSPC"] = StringUtil::trimCopy(ws.getAttribute("namespace"));

		logger << ("Web service " + ws_name + " found for appname " + appname) << endl;

		ClassStructure *clstruct = NULL;
		map<string, ClassStructure>::iterator it;
		for (it=allclsmap.begin();it!=allclsmap.end();++it)
		{
			if(it->second.getFullyQualifiedClassName()==ws.getAttribute("class"))
			{
				clstruct = &it->second;
				break;
			}
		}
		if(clstruct==NULL)
		{
			logger << ("Error generating web-service artifacts, as class "+ws.getAttribute("class") + "not found...") << endl;
			continue;
		}

		if(clstruct->getNamespace()=="" && gcntxt["WS_NMSPC"]=="")
		{
			logger << ("No namespace defined for web-service, skipping...") << endl;
			continue;
		}
		if(gcntxt["WS_NMSPC"]=="")
		{
			gcntxt["WS_NMSPC"] = clstruct->getNamespace();
		}
		StringUtil::replaceAll(gcntxt["WS_NMSPC"], "::", ".");

		vector<string> pinfo;
		bool isOpForSet = false;
		strVec info = ref.getAfcObjectData(*clstruct,false,pinfo,isOpForSet);
		headers.append("#include \""+ref.getClassPath(clstruct->getTreatedClassName(true))+"\"\n");

		set<string> allnmspcs;
		map<string, string> trgnms;
		for(unsigned int i=0;i<info.size();i++)
		{
			string temp,temp11;
			strMap in_out_info;
			temp = info.at(i);
			temp11 = temp.substr(temp.find("(")+1);
			temp = temp.substr(0,temp.find("("));
			temp11 = temp11.substr(0, temp11.find(")"));

			//StringUtil::replaceFirst(temp,"("," ");
			StringUtil::replaceAll(temp11,";","");
			StringUtil::replaceFirst(temp11,")","");
			strVec results,results1;
			StringUtil::split(results, temp, (" "));
			RegexUtil::replace(temp11, "[ \\t]*,[ \\t]", ",");
			StringUtil::split(results1, temp11, (","));

			string retType,methName,inp_params;
			if(results.size()<2)
				continue;
			if(results.size()>0 && (results.at(0)==it->second.getTreatedClassName(false) || temp.find("~")!=string::npos))
				continue;

			methName = results.at(1);

			in_out_info["RETURN"] = ws.getElementByName(methName).getAttribute("outname");
			if(in_out_info["RETURN"]=="")
				in_out_info["RETURN"] = "result";
			//logger << in_out_info["RETURN"] << flush;
			in_out_info["RETURNTYP"] = results.at(0);
			string xsdobjdef;
			if(results.at(0).find("vector<")!=string::npos)
			{
				string vecn = results.at(0);
				StringUtil::replaceFirst(vecn,"std::"," ");
				StringUtil::replaceFirst(vecn,"vector<"," ");
				StringUtil::replaceFirst(vecn,">"," ");
				StringUtil::trim(vecn);
				if(vecn=="int" || vecn=="string" || vecn=="short" || vecn=="float" || vecn=="double" || vecn=="bool" || vecn=="long long" || vecn=="long"
						|| vecn=="unsigned int" || vecn=="unsigned short" || vecn=="unsigned long long" || vecn=="unsigned long")
				{
					if(vecn=="long long")
					{
						vecn = "long";
					}
					else if(vecn=="unsigned long long")
					{
						vecn = "unsignedlong";
					}
					else if(vecn.find("unsigned")==0)
					{
						StringUtil::replaceAll(vecn, " ", "");
					}
					else if(vecn=="bool")
					{
						vecn = "boolean";
					}
					retType = "\n<xsd:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\""+in_out_info["RETURN"]+"\" type=\"xsd:"+vecn+"\"/>";
				}
				else
				{
					string trgnmspc;
					string fqcn = ref.getFullyQualifiedClassName(vecn, clstruct->getNamespaces());
					if(trgnms.find(fqcn)==trgnms.end())
					{
						xsdobjdef = ref.getXSDDefinitions(allclsmap, fqcn, ref, appname, trgnmspc, allnmspcs, gcntxt["WS_NMSPC"], resp);
						trgnms[fqcn] = trgnmspc;
					}
					else
						trgnmspc = trgnms[fqcn];
					logger << "in result " + vecn + " " + trgnmspc << endl;
					if(vecn.find("::")!=string::npos)
						vecn = vecn.substr(vecn.find_last_of("::")+1);
					logger << "in result after " + vecn + " " + trgnmspc << endl;
					retType = "\n<xsd:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\""+in_out_info["RETURN"]+"\" type=\""+trgnmspc+":"+vecn+"\"/>";
				}
			}
			else
			{
				if(results.at(0)!="void")
				{
					if(results.at(0)=="int" || results.at(0)=="string" || results.at(0)=="short" || results.at(0)=="float" || results.at(0)=="double"
							|| results.at(0)=="bool" || results.at(0)=="long long" || results.at(0)=="long"
							|| results.at(0)=="unsigned int" || results.at(0)=="unsigned short" || results.at(0)=="unsigned long long"
							|| results.at(0)=="unsigned long")
					{
						if(results.at(0)=="long long")
						{
							results.at(0) = "long";
						}
						else if(results.at(0)=="unsigned long long")
						{
							results.at(0) = "unsignedlong";
						}
						else if(results.at(0).find("unsigned")==0)
						{
							StringUtil::replaceAll(results.at(0), " ", "");
						}
						else if(results.at(0)=="bool")
						{
							results.at(0) = "boolean";
						}
						retType = "\n<xsd:element name=\""+in_out_info["RETURN"]+"\" type=\"xsd:"+results.at(0)+"\"/>";
					}
					else
					{
						string type = results.at(0);
						string trgnmspc;
						string fqcn = ref.getFullyQualifiedClassName(type, clstruct->getNamespaces());
						if(trgnms.find(fqcn)==trgnms.end())
						{
							xsdobjdef = ref.getXSDDefinitions(allclsmap, fqcn, ref, appname, trgnmspc, allnmspcs, gcntxt["WS_NMSPC"], resp);
							trgnms[fqcn] = trgnmspc;
						}
						else
							trgnmspc = trgnms[fqcn];
						logger << "in result " + type + " " + trgnmspc << endl;
						if(type.find("::")!=string::npos)
							type = type.substr(type.find_last_of("::")+1);
						logger << "in result after " + type + " " + trgnmspc << endl;
						retType = "\n<xsd:element name=\""+in_out_info["RETURN"]+"\" type=\""+trgnmspc+":"+type+"\"/>";
					}
				}
			}
			wsdl_obj_bind.append(xsdobjdef);

			for(unsigned int j=0;j<results1.size();j++)
			{
				string type;
				strVec results2;
				StringUtil::split(results2, results1.at(j), (" "));
				if(results2.size()<2)
				{
					results2.push_back("in"+CastUtil::lexical_cast<string>(j+1));
				}
				type = results2.at(0);
				int srn = j;
				stringstream ss;
				ss << srn;
				string te;
				ss >> te;
				if(type=="int" || type=="string" || type=="short" || type=="float" || type=="double" || type=="bool" || type=="long long" || type=="long"
						|| type=="unsigned int" || type=="unsigned short" || type=="unsigned long long" || type=="unsigned long")
				{
					string ttyp = type;
					if(type=="long long")
					{
						type = "long";
					}
					else if(type=="unsigned long long")
					{
						type = "unsignedlong";
					}
					else if(type.find("unsigned")==0)
					{
						StringUtil::replaceAll(type, " ", "");
					}
					else if(type=="bool")
					{
						type = "boolean";
					}
					inp_params.append("\n<xsd:element name=\""+results2.at(1)+"\" type=\"xsd:"+type+"\"/>");
					in_out_info[results2.at(1)] = ttyp;
				}
				else if(type!="")
				{
					if(results2.size()>=2)
					{
						in_out_info[results2.at(1)] = type;
					}
					else
					{
						logger << ("Invalid thing happening " + results1.at(j)) << endl;
					}
					strMap allfs,tyfs;
					string xsdobjdef, xdstype;
					if(type.find("vector<")!=string::npos && results2.size()==2)
					{
						string vecn = type;
						StringUtil::replaceFirst(vecn,"vector<"," ");
						StringUtil::replaceFirst(vecn,"std::"," ");
						StringUtil::replaceFirst(vecn,">"," ");
						StringUtil::trim(vecn);
						if(vecn=="int" || vecn=="short" || vecn=="float" || vecn=="double" || vecn=="bool" || vecn=="long long" || vecn=="long"
								|| vecn=="string" || vecn=="unsigned int" || vecn=="unsigned short" || vecn=="unsigned long long" || vecn=="unsigned long")
						{
							if(vecn=="long long")
							{
								vecn = "long";
							}
							else if(vecn=="unsigned long long")
							{
								vecn = "unsignedlong";
							}
							else if(vecn.find("unsigned")==0)
							{
								StringUtil::replaceAll(vecn, " ", "");
							}
							else if(vecn=="bool")
							{
								vecn = "boolean";
							}
							type = "std::vector<" + vecn + ">";
							inp_params.append("\n<xsd:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\""+results2.at(1)+"\" type=\"xsd:"+vecn+"\"/>");
						}
						else
						{
							string trgnmspc;
							string fqcn = ref.getFullyQualifiedClassName(vecn, clstruct->getNamespaces());
							type = "std::vector<" + fqcn + ">";
							if(trgnms.find(fqcn)==trgnms.end())
							{
								xsdobjdef = ref.getXSDDefinitions(allclsmap, fqcn, ref, appname, trgnmspc, allnmspcs, gcntxt["WS_NMSPC"], resp);
								trgnms[fqcn] = trgnmspc;
							}
							else
								trgnmspc = trgnms[fqcn];
							logger << "in result " + vecn + " " + trgnmspc << endl;
							if(vecn.find("::")!=string::npos)
								vecn = vecn.substr(vecn.find_last_of("::")+1);
							logger << "in result after " + vecn + " " + trgnmspc << endl;
							inp_params.append("\n<xsd:element minOccurs=\"0\" maxOccurs=\"unbounded\" name=\""+results2.at(1)+"\" type=\""+trgnmspc+":"+vecn+"\"/>");
						}
					}
					else if(results2.size()==2)
					{
						string trgnmspc;
						string fqcn = ref.getFullyQualifiedClassName(type, clstruct->getNamespaces());
						if(trgnms.find(fqcn)==trgnms.end())
						{
							xsdobjdef = ref.getXSDDefinitions(allclsmap, fqcn, ref, appname, trgnmspc, allnmspcs, gcntxt["WS_NMSPC"], resp);
							trgnms[fqcn] = trgnmspc;
						}
						else
							trgnmspc = trgnms[fqcn];
						logger << "in result " + type + " " + trgnmspc << endl;
						if(type.find("::")!=string::npos)
							type = type.substr(type.find_last_of("::")+1);
						logger << "in result after " + type + " " + trgnmspc << endl;
						inp_params.append("\n<xsd:element minOccurs=\"0\" name=\""+results2.at(1)+"\" type=\""+trgnmspc+":"+type+"\"/>");
					}

					wsdl_obj_bind.append(xsdobjdef);
				}
			}
			meth_info[methName] = in_out_info;
			StringContext cntxt;
			cntxt["METH_NAME"] = methName;
			cntxt["RET_TYPE"] = retType;
			cntxt["INP_PARAMS"] = inp_params;
			reqr_res_bind.append("\n"+TemplateEngine::evaluate(resp+"templateReqRes.wsdl",cntxt));
			wsdl_msgs.append("\n"+TemplateEngine::evaluate(resp+"templateWsdlMsg.wsdl",cntxt));
			wsdl_ops.append("\n"+TemplateEngine::evaluate(resp+"templateWsdlOpe.wsdl",cntxt));
			wsdl_bind.append("\n"+TemplateEngine::evaluate(resp+"templateWsdlBind.wsdl",cntxt));
		}
		ws_info[ows_name] = meth_info;
		gcntxt["REQ_RES_BINDING"] = reqr_res_bind;
		gcntxt["WSDL_MESSAGES"] = wsdl_msgs;
		gcntxt["WSDL_OPERATIONS"] = wsdl_ops;
		gcntxt["WSDL_BINDING"] = wsdl_bind;
		gcntxt["OBJ_BINDING"] = wsdl_obj_bind;
		string extranmspcs;
		if(allnmspcs.size()>0)
		{
			set<string>::iterator it;
			for(it=allnmspcs.begin();it!=allnmspcs.end();++it) {
				string nmspcid = *it;
				if(nmspcid!="tns")
				{
					string nmspcidval = Reflection::getNameSpaceIdValue(nmspcid);
					if(nmspcidval!="") {
						extranmspcs.append(" xmlns:" + nmspcid + "=\""+nmspcidval+"\"");
					}
				}
			}
		}
		gcntxt["EXTR_NMSPCS"] = extranmspcs;
		gcntxt["URL"] = "http://" + ip_address + "/" + appname;
		string wspath = gcntxt["URL"] + "/" + gcntxt["WS_PATH"];
		wsmap[wspath] = ws_name;
		wsdl = TemplateEngine::evaluate(resp+"template.wsdl",gcntxt);
		AfcUtil::writeTofile(resp+"../web/"+appname+"/public/"+ws_name+".wsdl",wsdl,true);
		//ws_funcs.append(obj_mapng);
		//ws_funcs.append(retObj_xml);
		//ws_funcs.append("extern \"C\"\n{\n");
		ws_inp_out_Map::iterator iter;
		for(iter=ws_info.begin();iter!=ws_info.end();iter++)
		{
			string ws_n = iter->first;
			meth_Map meth = iter->second;
			meth_Map::iterator iter1;
			for(iter1=meth.begin();iter1!=meth.end();iter1++)
			{
				string me_n = iter1->first;
				strMap pars = iter1->second;
				string ws_nn = ws_n;
				StringUtil::replaceAll(ws_nn, "::", "_");
				ws_funcs.append("string "+appname+me_n+ws_nn+"(Element* _req)\n{\nElement ele;\n");
				ws_funcs.append("string _retStr;\n");
				ws_funcs.append("try{\n/*_req->validateNs();*/\n");
				strMap::iterator iter2;
				string args;
				unsigned int ter = 1;
				//logger << me_n << ws_n << pars.size() << endl;
				for(iter2=pars.begin();iter2!=pars.end();iter2++)
				{
					if(iter2->first!="RETURN" && iter2->first!="RETURNTYP")
					{
						string argname =  iter2->first;
						if(iter2->second=="int" || iter2->second=="short" || iter2->second=="double" || iter2->second=="float" || iter2->second=="string"
								|| iter2->second=="bool" || iter2->second=="long" || iter2->second=="long long" || iter2->second=="unsigned int"
									|| iter2->second=="unsigned short" || iter2->second=="unsigned long" || iter2->second=="unsigned long long"
											|| iter2->second=="string")
						{
							ws_funcs.append("ele = _req->getElementByName(\""+argname+"\");\n");
							ws_funcs.append(iter2->second+" "+argname+";\n");
							ws_funcs.append("if(ele.getTagName()!=\"\")");
							ws_funcs.append(argname+" = CastUtil::lexical_cast<"+iter2->second+">(ele.getText());\n");
						}
						else if(iter2->second.find("vector<")!=string::npos)
						{
							string vecn = iter2->second;
							StringUtil::replaceFirst(vecn,"std::"," ");
							StringUtil::replaceFirst(vecn,"vector<"," ");
							StringUtil::replaceFirst(vecn,">"," ");
							StringUtil::trim(vecn);
							if(vecn=="int" || vecn=="short" || vecn=="float" || vecn=="double" || vecn=="bool" || vecn=="long long" || vecn=="long"
									|| vecn=="string" || vecn=="unsigned int" || vecn=="unsigned short" || vecn=="unsigned long long" || vecn=="unsigned long")
							{
								ws_funcs.append("vector<"+vecn+" > "+argname+";\n");
								ws_funcs.append("ElementList list = _req->getElementsByName(\""+argname+"\");\n");
								ws_funcs.append("for(int i=0;i<list.size();i++)");
								ws_funcs.append(argname+".push_back(CastUtil::lexical_cast<"+vecn+">(list.at(i).getText()));\n");
							}
							else
							{
								ws_funcs.append("vector<"+vecn+" > "+argname+";\n");
								ws_funcs.append("ElementList list = _req->getElementsByName(\""+argname+"\");\n");
								ws_funcs.append("for(int i=0;i<list.size();i++)\n{\n");
								ws_funcs.append(argname+".push_back(XMLSerialize::unserialize<vector<"+vecn+" > >(list.at(i).renderSerialization()));\n}\n");
							}
						}
						else
						{
							ws_funcs.append("ele = _req->getElementByName(\""+argname+"\");\n");
							ws_funcs.append(iter2->second+" "+argname+";\n");
							ws_funcs.append("if(ele.getTagName()!=\"\")");
							ws_funcs.append("{\nele.setTagName(\""+iter2->second+"\");");
							//ref.getTreatedFullyQualifiedClassName(argname, )
							ws_funcs.append("\n"+argname+" = XMLSerialize::unserialize<"+iter2->second+">(ele.renderSerialization());\n");
							ws_funcs.append("\ncout << ele.renderSerialization() << endl;");
							ws_funcs.append("}\n");
						}
						args.append(argname);
						if(ter++<pars.size()-2)
							args.append(",");
					}
				}
				ws_funcs.append(ws_n+" _obj;\n");

				//ws_funcs.append("AttributeList attl = _req->getAttributes();\n");
				//ws_funcs.append("AttributeList::iterator it;\n");
				ws_funcs.append("_retStr = \"<tns:\" + _req->getTagName() + \"Response\";\n");
				//ws_funcs.append("for(it=attl.begin();it!=attl.end();it++)\n");
				//ws_funcs.append("_retStr.append(\" \" + it->first + \"=\\\"\" + it->second + \"\\\" \");\n");
				ws_funcs.append("_retStr.append(\">\");\n");
				if(pars["RETURNTYP"]=="void")
				{
					ws_funcs.append("_obj."+me_n+"("+args+");\n");
				}
				else if(pars["RETURNTYP"]=="int" || pars["RETURNTYP"]=="short" || pars["RETURNTYP"]=="float" || pars["RETURNTYP"]=="double"
						|| pars["RETURNTYP"]=="bool" || pars["RETURNTYP"]=="long long" || pars["RETURNTYP"]=="long"
						|| pars["RETURNTYP"]=="unsigned int" || pars["RETURNTYP"]=="unsigned short" || pars["RETURNTYP"]=="string"
						|| pars["RETURNTYP"]=="unsigned long long" || pars["RETURNTYP"]=="unsigned long")
				{
					ws_funcs.append(pars["RETURNTYP"]+" _retval;\n");
					ws_funcs.append("_retval = _obj."+me_n+"("+args+");\n");
					ws_funcs.append("_retStr += \"<tns:"+pars["RETURN"]+">\"+CastUtil::lexical_cast<string>(_retval)+\"</tns:"+pars["RETURN"]+">\";\n");
				}
				else if(pars["RETURNTYP"]!="")
				{
					ws_funcs.append(pars["RETURNTYP"]+" _retval;\n");
					ws_funcs.append("_retval = _obj."+me_n+"("+args+");\n");
					if(pars["RETURNTYP"].find("vector<")!=string::npos)
					{
						string vecn = pars["RETURNTYP"];
						StringUtil::replaceFirst(vecn,"std::"," ");
						StringUtil::replaceFirst(vecn,"vector<"," ");
						StringUtil::replaceFirst(vecn,">"," ");
						StringUtil::trim(vecn);
						if(vecn=="string" || vecn=="int" || vecn=="short" || vecn=="float" || vecn=="double" || vecn=="bool" || vecn=="long long" || vecn=="long"
								|| vecn=="unsigned int" || vecn=="unsigned short" || vecn=="unsigned long long" || vecn=="unsigned long")
						{
							ws_funcs.append("for(int i=0;i<_retval.size();i++)");
							ws_funcs.append("_retStr += \"<tns:"+pars["RETURN"]+">\"+CastUtil::lexical_cast<string>(_retval.at(i))+\"</tns:"+pars["RETURN"]+">\";\n");
						}
						else
						{
							ws_funcs.append("string allnmspcs;\n");
							ws_funcs.append("for(int i=0;i<_retval.size();i++)\n{\n");
							ws_funcs.append("XmlParser parser(\"Parser\");\n");
							ws_funcs.append("allnmspcs = \"\";\n");
							ws_funcs.append("Document doc = parser.getDocument(XMLSerialize::serialize<"+vecn+">(_retval.at(i)));\n");
							ws_funcs.append("\ncout << XMLSerialize::serialize<"+vecn+">(_retval.at(i)) << endl;");
							ws_funcs.append("normalizeNamespaces(doc.getRootElement(),\""+appname+"\",allnmspcs);\n");
							ws_funcs.append("_retStr += \"<tns:"+pars["RETURN"]+">\"+doc.getRootElement().renderChildren()+\"</tns:"+pars["RETURN"]+">\";\n}\n");
						}
					}
					else
					{
						ws_funcs.append("string allnmspcs;\n");
						ws_funcs.append("XmlParser parser(\"Parser\");\n");
						ws_funcs.append("Document doc = parser.getDocument(XMLSerialize::serialize<"+pars["RETURNTYP"]+">(_retval));\n");
						ws_funcs.append("normalizeNamespaces(doc.getRootElement(),\""+appname+"\",allnmspcs);\n");
						ws_funcs.append("_retStr += \"<tns:"+pars["RETURN"]+">\"+doc.getRootElement().renderChildren()+\"</tns:"+pars["RETURN"]+">\";\n");
					}
				}
				ws_funcs.append("_retStr += \"</tns:\" + _req->getTagName() + \"Response>\";\n");
				ws_funcs.append("}catch(const Exception& e){\n");
				ws_funcs.append("return e.getMessage();\n} ");
				ws_funcs.append("catch(const char* e){\n");
				ws_funcs.append("return string(e);\n} ");
				ws_funcs.append("catch(...){\n");
				ws_funcs.append("return \"<soap:Fault><faultcode>soap:Server</faultcode><faultstring>Exception occurred</faultstring></soap:Fault>\";\n}\n");
				ws_funcs.append("return _retStr;\n}\n");
			}
			//ws_funcs.append("}\n");
		}
		//AfcUtil::writeTofile(rtdcfp+"WsInterface.cpp",ws_funcs,true);
	}
	return ws_funcs;
}
Пример #11
0
FFEADContext::FFEADContext(const std::string& depFile, const std::string& appName)
{
	reflector = NULL;
	cleared = false;
	logger = LoggerFactory::getLogger("FFEADContext");
	XmlParser parser("Parser");
	Document doc;
	parser.readDocument(depFile, doc);
	const Element& root = doc.getRootElement();
	ElementList eles = root.getChildElements();
	if(eles.size()>0 && root.getTagName()=="beans")
	{
		for (unsigned int var = 0; var < eles.size(); var++)
		{
			Element* ele = &(eles.at(var));
			if(ele->getTagName()=="bean")
			{
				Bean bean;
				bean.appName = appName;
				bean.name = ele->getAttribute("name");
				bean.value = ele->getAttribute("value");
				bean.inbuilt = ele->getAttribute("inbuilt");
				if(ele->getAttribute("bean")!="")
					throw std::runtime_error("Invalid attribute");
				bean.bean = ele->getAttribute("bean");
				bean.clas = ele->getAttribute("class");
				bean.intfType = ele->getAttribute("intfType");
				bean.injectAs = ele->getAttribute("injectAs");
				bean.scope = ele->getAttribute("scope");
				bean.realbean = true;
				ElementList eleeles = ele->getChildElements();
				if(eleeles.size()==0)
				{

				}
				else
				{
					for (unsigned int var1 = 0; var1 < eleeles.size(); var1++)
					{
						Element* ele1 = &(eleeles.at(var1));
						if(ele1->getTagName()=="inject")
						{
							if(ele1->getAttribute("bean")!="")
							{
								bean.injs.push_back(appName+ele1->getAttribute("bean"));
								if(ele1->getAttribute("name")!="")
									bean.names.push_back(appName+ele1->getAttribute("name"));
								else
									bean.names.push_back(appName+ele1->getAttribute("bean"));
								bean.types.push_back(ele1->getAttribute("intfType"));
							}
							else
							{
								Bean beanc;
								beanc.appName = appName;
								beanc.name = ele1->getAttribute("name");
								beanc.value = ele1->getAttribute("value");
								beanc.inbuilt = ele1->getAttribute("inbuilt");
								beanc.clas = ele1->getAttribute("class");
								beanc.intfType = ele1->getAttribute("intfType");
								bean.scope = ele1->getAttribute("scope");
								beanc.realbean = false;
								injbns[beanc.appName+beanc.name] = beanc;
								bean.injs.push_back(beanc.appName+beanc.name);
								bean.names.push_back(beanc.appName+beanc.name);
							}
						}
						else
						{
							throw std::runtime_error("Invalid tag");
						}
					}
				}
				beans[bean.appName+bean.name] = bean;
			}
			else
			{
				throw std::runtime_error("Invalid tag");
			}
		}
	}
}
Пример #12
0
void* MethodInvoc::service(void* arg)
{
	int fd = *(int*)arg;
	init();
	string methInfo,retValue;
	_methinv_instance->server.Receive(fd,methInfo,1024);
	methInfo =methInfo.substr(0,methInfo.find_last_of(">")+1);
	try
	{
		XmlParser parser("Parser");
		if(methInfo.find("lang=\"c++\"")!=string::npos || methInfo.find("lang='c++'")!=string::npos)
		{
			Document doc = parser.getDocument(methInfo);
			Element message = doc.getRootElement();
			if(message.getTagName()!="method")
			{
				throw MethodInvokerException("No method Tag\n",retValue);
			}
			if(message.getAttributes().size()<3)
			{
				throw MethodInvokerException("name,class and lang are mandatory attributes\n",retValue);
			}
			else if(message.getAttribute("name")=="")
			{
				throw MethodInvokerException("name attribute missing\n",retValue);
			}
			else if(message.getAttribute("className")=="")
			{
				throw MethodInvokerException("class attribute missing\n",retValue);
			}
			else if(message.getAttribute("lang")=="")
			{
				throw MethodInvokerException("lang attribute missing\n",retValue);
			}
			if(message.getChildElements().size()!=1)
			{
				throw MethodInvokerException("message tag should have only one child tag\n",retValue);
			}
			else if(message.getChildElements().at(0).getTagName()!="args")
			{
				throw MethodInvokerException("message tag should have an args child tag\n",retValue);
			}
			XMLSerialize ser;
			Reflector reflector;
			args argus;
			vals valus;
			ElementList argts = message.getChildElements().at(0).getChildElements();
			for (unsigned var = 0; var < argts.size();  var++)
			{
				void *value = NULL;
				Element arg = argts.at(var);
				if(arg.getTagName()!="argument" || arg.getAttribute("type")=="")
					throw MethodInvokerException("every argument tag should have a name and type attribute\n",retValue);
				if(arg.getText()=="" && arg.getChildElements().size()==0)
					throw MethodInvokerException("argument value missing\n",retValue);
				if(arg.getAttribute("type")=="int")
				{
					int *vt = new int;
					*vt = CastUtil::lexical_cast<int>(arg.getText());
					value = vt;
				}
				else if(arg.getAttribute("type")=="float")
				{
					float *vt = new float;
					*vt = CastUtil::lexical_cast<float>(arg.getText());
					value = vt;
				}
				else if(arg.getAttribute("type")=="double")
				{
					double *vt = new double;
					*vt = CastUtil::lexical_cast<double>(arg.getText());
					value = vt;
				}
				else if(arg.getAttribute("type")=="string")
				{
					string *vt = new string;
					*vt = CastUtil::lexical_cast<string>(arg.getText());
					value = vt;
				}
				else if(arg.getAttribute("type")!="")
				{
					Element obj = arg.getChildElements().at(0);
					string objxml = obj.render();
					string objClassName = obj.getTagName();
					value = ser.unSerializeUnknown(objxml,arg.getAttribute("type"));
				}
				argus.push_back(arg.getAttribute("type"));
				valus.push_back(value);
			}
			string className = message.getAttribute("className");
			string returnType = message.getAttribute("returnType");
			string lang = message.getAttribute("lang");
			ClassInfo clas = reflector.getClassInfo(className);
			string methodName = message.getAttribute("name");;
			if(clas.getClassName()=="")
			{
				throw MethodInvokerException("class does not exist or is not in the library path\n",retValue);
			}
			Method meth = clas.getMethod(methodName,argus);
			if(meth.getMethodName()=="")
			{
				throw MethodInvokerException("method does not exist for the class or the class does not exist in the library path\n",retValue);
			}
			else
			{
				args argus;
				Constructor ctor = clas.getConstructor(argus);
				void *_temp = reflector.newInstanceGVP(ctor);
				if(returnType=="void" || returnType=="")
				{
					reflector.invokeMethod<void*>(_temp,meth,valus);
					retValue = ("<return:void></return:void>");
				}
				else
				{
					if(returnType=="int")
					{
						int retv = reflector.invokeMethod<int>(_temp,meth,valus);
						retValue = ("<return:int>"+CastUtil::lexical_cast<string>(retv)+"</return:int>");
					}
					else if(returnType=="float")
					{
						float retv = reflector.invokeMethod<float>(_temp,meth,valus);
						retValue = ("<return:float>"+CastUtil::lexical_cast<string>(retv)+"</return:float>");
					}
					else if(returnType=="double")
					{
						double retv = reflector.invokeMethod<double>(_temp,meth,valus);
						retValue = ("<return:double>"+CastUtil::lexical_cast<string>(retv)+"</return:double>");
					}
					else if(returnType=="string")
					{
						string retv = reflector.invokeMethod<string>(_temp,meth,valus);
						retValue = ("<return:string>"+retv+"</return:string>");
					}
					else if(returnType!="")
					{
						void* retobj = reflector.invokeMethodUnknownReturn(_temp,meth,valus);
						string oxml = ser.serializeUnknown(retobj,returnType);
						retValue = ("<return:"+returnType+">"+oxml+"</return:"+returnType+">");
					}
				}

			}
		}
		else
		{
			retValue = "<return:exception>This is a C++ daemon</return:exception>";
		}
		if(retValue!="")
			_methinv_instance->server.Send(fd,retValue);
		close(fd);
	}
	catch(MethodInvokerException *e)
	{
		_methinv_instance->server.Send(fd,retValue);
		close(fd);
	}
	catch(...)
	{
		retValue = ("<return:exception>XmlParseException occurred</return:exception>");
		_methinv_instance->server.Send(fd,retValue);
		close(fd);
	}
	return NULL;
}