vector<Procedure> SpecificationParser::GetProceduresFromString(const string &content) throw(JsonRpcException)
{
Json::Reader reader;
Json::Value val;
if(!reader.parse(content,val))
{
throw JsonRpcException(Errors::ERROR_RPC_JSON_PARSE_ERROR, " specification file contains syntax errors");
}
if (!val.isArray())
{
throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, " top level json value is not an array");
}
vector<Procedure> result;
map<string, Procedure> procnames;
for (unsigned int i = 0; i < val.size(); i++)
{
Procedure proc;
GetProcedure(val[i], proc);
if (procnames.find(proc.GetProcedureName()) != procnames.end())
{
throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, "Procedurename not uniqe: " + proc.GetProcedureName());
}
procnames[proc.GetProcedureName()] = proc;
result.push_back(proc);
}
return result;
}
void CPPClientStubGenerator::generateProcCall(Procedure &proc)
{
string call;
if (proc.GetProcedureType() == RPC_METHOD)
{
call = TEMPLATE_METHODCALL;
cg.writeLine(replaceAll(call, "<name>", proc.GetProcedureName()));
call = TEMPLATE_RETURNCHECK;
replaceAll2(call,"<cast>", CPPHelper::isCppConversion(proc.GetReturnType()));
cg.writeLine(call);
cg.increaseIndentation();
call = TEMPLATE_RETURN;
replaceAll2(call,"<cast>", CPPHelper::toCppConversion(proc.GetReturnType()));
cg.writeLine(call);
cg.decreaseIndentation();
cg.writeLine("else");
cg.increaseIndentation();
cg.writeLine("throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());");
cg.decreaseIndentation();
}
else
{
call = TEMPLATE_NOTIFICATIONCALL;
replaceAll2(call, "<name>", proc.GetProcedureName());
cg.writeLine(call);
}
}
void CPPClientStubGenerator::generateMethod(Procedure &proc)
{
string procsignature = TEMPLATE_CPPCLIENT_SIGMETHOD;
string returntype = CPPHelper::toCppType(proc.GetReturnType());
if (proc.GetProcedureType() == RPC_NOTIFICATION)
returntype = "void";
replaceAll2(procsignature, "<returntype>", returntype);
replaceAll2(procsignature, "<methodname>", CPPHelper::normalizeString(proc.GetProcedureName()));
replaceAll2(procsignature, "<parameters>", CPPHelper::generateParameterDeclarationList(proc));
cg.writeLine(procsignature);
cg.writeLine("{");
cg.increaseIndentation();
cg.writeLine("Json::Value p;");
generateAssignments(proc);
generateProcCall(proc);
cg.decreaseIndentation();
cg.writeLine("}");
}
int RpcProtocolServer::ValidateRequest(const Json::Value& request)
{
int error = 0;
Procedure* proc;
if (!(request.isMember(KEY_REQUEST_METHODNAME)
&& request.isMember(KEY_REQUEST_VERSION)
&& request.isMember(KEY_REQUEST_PARAMETERS)))
{
error = Errors::ERROR_RPC_INVALID_REQUEST;
}
else
{
map<string, Procedure*>::iterator it = procedures->find(request[KEY_REQUEST_METHODNAME].asString());
if (it != this->procedures->end())
{
proc = (*this->procedures)[request[KEY_REQUEST_METHODNAME].asString()];
if(request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_NOTIFICATION)
{
error = Errors::ERROR_SERVER_PROCEDURE_IS_NOTIFICATION;
}
else if(!request.isMember(KEY_REQUEST_ID) && proc->GetProcedureType() == RPC_METHOD)
{
error = Errors::ERROR_SERVER_PROCEDURE_IS_METHOD;
}
else if (proc->ValdiateParameters(request[KEY_REQUEST_PARAMETERS]))
{
if (this->authManager != NULL)
{
error = this->authManager->CheckPermission(
request[KEY_AUTHENTICATION],
proc->GetProcedureName());
}
}
else
{
error = Errors::ERROR_RPC_INVALID_PARAMS;
}
}
else
{
error = Errors::ERROR_RPC_METHOD_NOT_FOUND;
}
}
return error;
}
procedurelist_t *SpecificationParser::GetProceduresFromString(const string &content) throw(JsonRpcException)
{
Json::Reader reader;
Json::Value val;
if(!reader.parse(content,val)) {
throw JsonRpcException(Errors::ERROR_RPC_JSON_PARSE_ERROR, " specification file contains syntax errors");
}
procedurelist_t* procedures = new procedurelist_t();
Procedure* proc;
for (unsigned int i = 0; i < val.size(); i++)
{
proc = GetProcedure(val[i]);
(*procedures)[proc->GetProcedureName()] = proc;
}
return procedures;
}
void SpecificationWriter::procedureToJsonValue (const Procedure &procedure, Json::Value &target)
{
target[KEY_SPEC_PROCEDURE_NAME] = procedure.GetProcedureName();
if(procedure.GetProcedureType() == RPC_METHOD)
{
target[KEY_SPEC_RETURN_TYPE] = toJsonLiteral(procedure.GetReturnType());
}
for(parameterNameList_t::const_iterator it = procedure.GetParameters().begin(); it != procedure.GetParameters().end(); ++it)
{
if(procedure.GetParameterDeclarationType() == PARAMS_BY_NAME)
{
target[KEY_SPEC_PROCEDURE_PARAMETERS][it->first] = toJsonLiteral(it->second);
}
else
{
target[KEY_SPEC_PROCEDURE_PARAMETERS].append(toJsonLiteral(it->second));
}
}
}