jsonrpc-cpp-devel — Discussions on development of JsonRpc-Cpp

Re: [Jsonrpc-cpp-devel] Multithreaded server

[Ditwin - C. <co...@di...>]

 Just for information, d you have reports and statistics about that ?
>


I have two implementations of my website. The first uses Symfony, the
second is implemented in PHP, and uses a webservice written with JSON RPC
CPP.

I used Apache Benchmark (ab) to compare the two versions. The second
version is really faster with about 100 calls. But with a more



>
>  So, make the Recv function to create his own thread, run it and closes
>> the socket.
>>
>
>  Do you mean, create one thread per new request ?


Yes. But it could be possible to create a set of initial thread when the
server starts ? This could be more effective this way, rather than creating
one thread, process the method, destroy the thread ... Create a new new and
so on.



The mutex is sometime necessary... it depends if you have objects you would
> like to share between threads.
>

Ok, I don't need to share objects between thread, because each method
create his own objects depending on the requests.

Re: [Jsonrpc-cpp-devel] Multithreaded server

[Sebastien V. <seb...@cp...>]

Hi,

Le 15/02/2012 01:26, PEI Normandie a écrit :
>
> My program uses only one thread for treatments. I think Recv should 
> create his own thread.
>
> The "select" function allows some concurrent connections. But when the 
> connections are about hundreds the server is dead, takes all memory 
> and sleeps ...
>

Just for information, d you have reports and statistics about that ?

> So, make the Recv function to create his own thread, run it and closes 
> the socket.

Do you mean, create one thread per new request ?

>
> Why should we use a Mutex ? I hope the server's methods can be used 
> concurrently. If it can't, does that mean that multithreaded server is 
> useless ?
>

The mutex is sometime necessary... it depends if you have objects you 
would like to share between threads.

Regards,
--
Seb

Re: [Jsonrpc-cpp-devel] Multithreaded server

[PEI N. <pei...@gm...>]

My program uses only one thread for treatments. I think Recv should create
his own thread.

The "select" function allows some concurrent connections. But when the
connections are about hundreds the server is dead, takes all memory and
sleeps ...

So, make the Recv function to create his own thread, run it and closes the
socket.

Why should we use a Mutex ? I hope the server's methods can be used
concurrently. If it can't, does that mean that multithreaded server is
useless ?

Re: [Jsonrpc-cpp-devel] Multithreaded server

[Sebastien V. <seb...@cp...>]

Hi,

Please keep the discussion on the mailing-list (I cc it) as other users 
might be interrested to multithreaded JSON-RPC server implementation.

More inline.

Le 12/02/2012 17:51, PEI Normandie a écrit :
> Ok,
>
> I saw some Thread objects in Server class but no real implementation 
> in TCPServer class.
>

Yes I have just created the Thread/Mutex abstraction class but the 
*Server class do not use them for the moment.

> I am not really a specialist of network programming. I'm learning ... 
> even if I have some experience in general programming.
>
> I tried to adapt your code to make it multithreaded ... But memory 
> corruption occured.
>
> I have problems to make it work. I will have to make it secured AND 
> robust for a website using it, which have more than 300 000 visitors a 
> month.
>
> I try to submit you some code as soon as possible.
>

OK. Please also explain your design (one thread for recv() ? how many 
thread for processing ? ...). We should also think about making the UDP 
server multithreaded too.


Regards,
--
Seb

>
> Médéric
>
> Je viens de voir que je réponds à ton adresse perso, donc on pourra 
> continuer en Français si tu veux :)
>
>
>
> On 12 February 2012 15:35, Sebastien Vincent 
> <seb...@cp... 
> <mailto:seb...@cp...>> wrote:
>
>     Hi,
>
>     This is on the TODO list but unfortunately I have not enough free
>     time to make design and implementation.
>
>     You can begin work on it. But it will be great to discuss
>     design/implementation on this mailing-list.
>
>     FYI, there are some classes to deals with thread in a portable
>     manner in system.cpp.
>
>     Best regards,
>     --
>     Seb
>
>     Le 11/02/2012 21:33, Ditwin Normandie a écrit :
>>     Hi all !
>>
>>     I'm developping a TCP server  with JSON RPC C++.
>>
>>     I really need a multithreaded server to deploy it on a webservice
>>     having a .. .respectable traffic.
>>
>>     Does anyone have already created a multithreaded version ? Could
>>     anyone help to do it ?
>>
>>     Thanks in advance !
>>
>>     M. Salles
>>     PS: Write in English or French
>>     ------------------------------------------------------------------------------
>>     Virtualization&  Cloud Management Using Capacity Planning
>>     Cloud computing makes use of virtualization - but cloud computing
>>     also focuses on allowing computing to be delivered as a service.
>>     http://www.accelacomm.com/jaw/sfnl/114/51521223/
>>     _______________________________________________
>>     Jsonrpc-cpp-devel mailing list
>>     Jso...@li...  <mailto:Jso...@li...>
>>     https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel
>
>
>     ------------------------------------------------------------------------------
>     Virtualization & Cloud Management Using Capacity Planning
>     Cloud computing makes use of virtualization - but cloud computing
>     also focuses on allowing computing to be delivered as a service.
>     http://www.accelacomm.com/jaw/sfnl/114/51521223/
>     _______________________________________________
>     Jsonrpc-cpp-devel mailing list
>     Jso...@li...
>     <mailto:Jso...@li...>
>     https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel
>
>
>
>
> -- 
> Cordialement,
>
> M. Salles
> Ditwin.fr
> Réseau social professionnel pour la recherche d'emploi et le recrutement
> http://www.ditwin.fr
> Mel: co...@di... <mailto:co...@di...>

Re: [Jsonrpc-cpp-devel] Multithreaded server

[Sebastien V. <seb...@cp...>]

Hi,

This is on the TODO list but unfortunately I have not enough free time 
to make design and implementation.

You can begin work on it. But it will be great to discuss 
design/implementation on this mailing-list.

FYI, there are some classes to deals with thread in a portable manner in 
system.cpp.

Best regards,
--
Seb

Le 11/02/2012 21:33, Ditwin Normandie a écrit :
> Hi all !
>
> I'm developping a TCP server  with JSON RPC C++.
>
> I really need a multithreaded server to deploy it on a webservice 
> having a .. .respectable traffic.
>
> Does anyone have already created a multithreaded version ? Could 
> anyone help to do it ?
>
> Thanks in advance !
>
> M. Salles
> PS: Write in English or French
>
>
> ------------------------------------------------------------------------------
> Virtualization&  Cloud Management Using Capacity Planning
> Cloud computing makes use of virtualization - but cloud computing
> also focuses on allowing computing to be delivered as a service.
> http://www.accelacomm.com/jaw/sfnl/114/51521223/
>
>
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

[Jsonrpc-cpp-devel] Multithreaded server

[Ditwin N. <pei...@gm...>]

Hi all !

I'm developping a TCP server  with JSON RPC C++.

I really need a multithreaded server to deploy it on a webservice having a
.. .respectable traffic.

Does anyone have already created a multithreaded version ? Could anyone
help to do it ?

Thanks in advance !

M. Salles
PS: Write in English or French

Re: [Jsonrpc-cpp-devel] Status of JsonRpc-Cpp Http Patch

[Sebastien V. <seb...@cp...>]

Hi Brian,

I have finally found time to commit your HTTP JSON-RPC client patch.

Thanks again.

Best regards,
--
Seb

Le 27/01/2012 17:41, Sebastien Vincent a écrit :
> Hi Brian,
>
> Le 27/01/2012 17:23, Panneton, Brian C CTR (US) a écrit :
>> I was just wondering what the current status is of the patch that I 
>> provided.
>>
>
> I have not found the time to integrate it in the trunk :/, but I will 
> do it. I have another patch in my sandbox that supports HTTP GET 
> method server side (it is on the feature tracker of sourceforge 
> project website) and I will try to integrate too.
>
>
>> Also, Sebastian, your email address no longer appears to work.
>
> Hmm, which address ? this one I am replying from or another ?
>
> Regards,
> --
> Seb
>
>>
>> Thanks,
>> Brian
>>
>>
>> ------------------------------------------------------------------------------
>> Try before you buy = See our experts in action!
>> The most comprehensive online learning library for Microsoft developers
>> is just $99.99! Visual Studio, SharePoint, SQL - plus HTML5, CSS3, MVC3,
>> Metro Style Apps, more. Free future releases when you subscribe now!
>> http://p.sf.net/sfu/learndevnow-dev2
>>
>>
>> _______________________________________________
>> Jsonrpc-cpp-devel mailing list
>> Jso...@li...
>> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel
>

Re: [Jsonrpc-cpp-devel] Status of JsonRpc-Cpp Http Patch

[Sebastien V. <seb...@cp...>]

Hi Brian,

Le 27/01/2012 17:23, Panneton, Brian C CTR (US) a écrit :
> I was just wondering what the current status is of the patch that I 
> provided.
>

I have not found the time to integrate it in the trunk :/, but I will do 
it. I have another patch in my sandbox that supports HTTP GET method 
server side (it is on the feature tracker of sourceforge project 
website) and I will try to integrate too.


> Also, Sebastian, your email address no longer appears to work.

Hmm, which address ? this one I am replying from or another ?

Regards,
--
Seb

>
> Thanks,
> Brian
>
>
> ------------------------------------------------------------------------------
> Try before you buy = See our experts in action!
> The most comprehensive online learning library for Microsoft developers
> is just $99.99! Visual Studio, SharePoint, SQL - plus HTML5, CSS3, MVC3,
> Metro Style Apps, more. Free future releases when you subscribe now!
> http://p.sf.net/sfu/learndevnow-dev2
>
>
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

[Jsonrpc-cpp-devel] Status of JsonRpc-Cpp Http Patch

[Panneton, B. C C. (US) <bri...@ma...>]

I was just wondering what the current status is of the patch that I provided.

Also, Sebastian, your email address no longer appears to work.

Thanks,
Brian

[Jsonrpc-cpp-devel] HTTP over JSON Patch

[Brian P. <bri...@gm...>]

Sebastian,

Your email address no longer seems to work. I was just wondering what the
status of the patch I provided is.

Thanks,
Brian Panneton

Re: [Jsonrpc-cpp-devel] Outdated info

[Sebastien V. <seb...@cp...>]

Hi,

Yes I understand. But unfortunately I cannot login into the json-rpc.org 
wiki to change it.

Regards,
--
Seb

Le 22/09/2011 00:10, Pavel Bažant a écrit :
> http://json-rpc.org/wiki/implementations
> says the library is GPL, while the new version is LGPL. Transition to
> LGPL may be an important issue for many people (I dislike GPL --
> especially for libraries -- so this is good news for me:) ).
> Pavel Bazant
>
> ------------------------------------------------------------------------------
> All the data continuously generated in your IT infrastructure contains a
> definitive record of customers, application performance, security
> threats, fraudulent activity and more. Splunk takes this data and makes
> sense of it. Business sense. IT sense. Common sense.
> http://p.sf.net/sfu/splunk-d2dcopy1
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

[Jsonrpc-cpp-devel] Outdated info

[Pavel B. <pb...@gm...>]

http://json-rpc.org/wiki/implementations
says the library is GPL, while the new version is LGPL. Transition to
LGPL may be an important issue for many people (I dislike GPL --
especially for libraries -- so this is good news for me:) ).
Pavel Bazant

[Jsonrpc-cpp-devel] Has anyone started with HTTP?

[Panneton, B. C U. C. (US) <bri...@ma...>]

I see that many people are requesting HTTP support and that many people have said they will start it, but has anyone actually began implementing it?

Thanks,
Brian

Re: [Jsonrpc-cpp-devel] Scons error: "ambiguous overload"

[Sebastien V. <seb...@cp...>]

Hi,

What is your environment (OS, g++ version, jsoncpp version, ...) ?
 
--
Seb


On Mon, 8 Aug 2011 10:27:11 +0100 (IST), Eamonn Hynes
<eam...@al...> wrote:
> I hope someone can help me get jsonrpc-cpp to compile.
> 
> When I type `scons` as per the documentation, I get:
> 
>  eamorr@Compaq6000:~/Desktop/jsonrpc-cpp$ scons
>  scons: Reading SConscript files ...
>  scons: done reading SConscript files.
>  scons: Building targets ...
>  g++ -o src/jsonrpc_handler.os -c -std=c++98 -Wall -Wextra -pedantic
> -Wredundant-decls -Wshadow -Werror -O2 -fPIC src/jsonrpc_handler.cpp
>  src/jsonrpc_handler.cpp: In member function ‘bool
> Json::Rpc::Handler::Process(const std::string&, Json::Value&)’:
>  src/jsonrpc_handler.cpp:208:25: error: ambiguous overload for
> ‘operator[]’ in ‘root[i]’
>  /usr/local/include/json/value.h:322:14: note: candidates are:
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>  /usr/local/include/json/value.h:329:14: note: Json::Value&
> Json::Value::operator[](int)
>  /usr/local/include/json/value.h:334:20: note: const Json::Value&
> Json::Value::operator[](Json::Value::ArrayIndex) const
>  /usr/local/include/json/value.h:339:20: note: const Json::Value&
> Json::Value::operator[](int) const
>  src/jsonrpc_handler.cpp:213:23: error: ambiguous overload for
> ‘operator[]’ in ‘response[j]’
>  /usr/local/include/json/value.h:322:14: note: candidates are:
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>  /usr/local/include/json/value.h:329:14: note: Json::Value&
> Json::Value::operator[](int)
>  /usr/local/include/json/value.h:334:20: note: const Json::Value&
> Json::Value::operator[](Json::Value::ArrayIndex) const
>  /usr/local/include/json/value.h:339:20: note: const Json::Value&
> Json::Value::operator[](int) const
>  scons: *** [src/jsonrpc_handler.os] Error 1
>  scons: building terminated because of errors.
> 
> Here is `src/jsonrpc_handler.cpp` (I've marked lines 208 and 213):
> 
>  /*
>  * JsonRpc-Cpp - JSON-RPC implementation.
>  * Copyright (C) 2008-2011 Sebastien Vincent 
>  *
>  * This program is free software: you can redistribute it and/or
> modify
>  * it under the terms of the GNU Lesser General Public License as
> published by
>  * the Free Software Foundation, either version 3 of the License, or
>  * (at your option) any later version.
>  *
>  * This program is distributed in the hope that it will be useful,
>  * but WITHOUT ANY WARRANTY; without even the implied warranty of
>  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>  * GNU Lesser General Public License for more details.
>  *
>  * You should have received a copy of the GNU Lesser General Public
> License
>  * along with this program. If not, see .
>  */
> 
>  /**
>  * file jsonrpc_handler.cpp
>  * brief JSON-RPC server processor engine.
>  * author Sebastien Vincent
>  */
> 
>  #include "jsonrpc_handler.h"
> 
>  namespace Json
>  {
> 
>  namespace Rpc
>  {
> 
>  CallbackMethod::~CallbackMethod()
>  {
>  }
> 
>  Handler::Handler()
>  {
>  /* add a RPC method that list the actual RPC methods contained in
> the Handler */
>  Json::Value root;
> 
>  root["description"] = "List the RPC methods available";
>  root["parameters"] = Json::Value::null;
>  root["returns"] = "Object that contains description of all methods
> registered";
> 
>  AddMethod(new RpcMethod(*this, &Handler::SystemDescribe,
> std::string("system.describe"), root));
>  }
> 
>  Handler::~Handler()
>  {
>  /* delete all objects from the list */
>  for(std::list::const_iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  delete (*it);
>  }
>  m_methods.clear();
>  }
> 
>  void Handler::AddMethod(CallbackMethod* method)
>  {
>  m_methods.push_back(method);
>  }
> 
>  void Handler::DeleteMethod(const std::string& name)
>  {
>  /* do not delete system defined method */
>  if(name == "system.describe")
>  {
>  return;
>  }
> 
>  for(std::list::iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  if((*it)->GetName() == name)
>  {
>  delete (*it);
>  m_methods.erase(it);
>  break;
>  }
>  }
>  }
> 
>  bool Handler::SystemDescribe(const Json::Value& msg, Json::Value&
> response)
>  {
>  Json::Value methods;
>  response["jsonrpc"] = "2.0";
>  response["id"] = msg["id"];
> 
>  for(std::list::iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  methods[(*it)->GetName()] = (*it)->GetDescription();
>  }
> 
>  response["result"] = methods;
>  return true;
>  }
> 
>  std::string Handler::GetString(Json::Value value)
>  {
>  return m_writer.write(value);
>  }
> 
>  bool Handler::Check(const Json::Value& root, Json::Value& error)
>  {
>  Json::Value err;
> 
>  /* check the JSON-RPC version => 2.0 */
>  if(!root.isObject() || !root.isMember("jsonrpc") || root["jsonrpc"]
> != "2.0") 
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  if(root.isMember("id") && (root["id"].isArray() ||
> root["id"].isObject()))
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  /* extract "method" attribute */
>  if(!root.isMember("method") || !root["method"].isString())
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  return true;
>  }
> 
>  bool Handler::Process(const Json::Value& root, Json::Value&
> response)
>  {
>  Json::Value error;
>  std::string method;
> 
>  if(!Check(root, error))
>  {
>  response = error;
>  return false;
>  }
> 
>  method = root["method"].asString();
> 
>  if(method != "")
>  {
>  CallbackMethod* rpc = Lookup(method);
>  if(rpc)
>  {
>  return rpc->Call(root, response);
>  }
>  }
> 
>  /* forge an error response */
>  response["id"] = root.isMember("id") ? root["id"] :
> Json::Value::null;
>  response["jsonrpc"] = "2.0";
> 
>  error["code"] = METHOD_NOT_FOUND;
>  error["message"] = "Method not found.";
>  response["error"] = error;
> 
>  return false;
>  }
> 
>  bool Handler::Process(const std::string& msg, Json::Value& response)
>  {
>  Json::Value root;
>  Json::Value error;
>  bool parsing = false;
> 
>  /* parsing */
>  parsing = m_reader.parse(msg, root);
> 
>  if(!parsing)
>  {
>  /* request or batched call is not in JSON format */
>  response["id"] = Json::Value::null;
>  response["jsonrpc"] = "2.0";
> 
>  error["code"] = PARSING_ERROR;
>  error["message"] = "Parse error.";
>  response["error"] = error; 
>  return false;
>  }
> 
>  if(root.isArray())
>  {
>  /* batched call */
>  size_t i = 0;
>  size_t j = 0;
> 
>  for(i = 0 ; i < root.size() ; i++)
>  {
>  Json::Value ret;
>  Process(root[i], ret); //line 208!
> 
>  if(ret != Json::Value::null)
>  {
>  /* it is not a notification, add to array of responses */
>  response[j] = ret; //line 213!
>  j++;
>  }
>  }
>  return true;
>  }
>  else
>  {
>  return Process(root, response);
>  }
>  }
> 
>  bool Handler::Process(const char* msg, Json::Value& response)
>  {
>  std::string str(msg);
> 
>  return Process(str, response);
>  }
> 
>  CallbackMethod* Handler::Lookup(const std::string& name) const
>  {
>  for(std::list::const_iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  if((*it)->GetName() == name)
>  {
>  return (*it);
>  }
>  }
> 
>  return 0;
>  }
> 
>  } /* namespace Rpc */
> 
>  } /* namespace Json */
> 
> I'm really hoping someone might be able to point me in the right
> direction.
> 
> Many thanks in advance,

Re: [Jsonrpc-cpp-devel] Scons error: "ambiguous overload"

[Sebastien V. <seb...@cp...>]

Hi again,

It is an error due to g++ 4.6.

I have fixed it in SVN revision 58.

Regards,
--
Seb

Le 08/08/2011 11:27, Eamonn Hynes a écrit :
> I hope someone can help me get jsonrpc-cpp to compile.
>
> When I type `scons` as per the documentation, I get:
>
>     eamorr@Compaq6000:~/Desktop/jsonrpc-cpp$ scons
>     scons: Reading SConscript files ...
>     scons: done reading SConscript files.
>     scons: Building targets ...
>     g++ -o src/jsonrpc_handler.os -c -std=c++98 -Wall -Wextra 
> -pedantic -Wredundant-decls -Wshadow -Werror -O2 -fPIC 
> src/jsonrpc_handler.cpp
>     src/jsonrpc_handler.cpp: In member function ‘bool 
> Json::Rpc::Handler::Process(const std::string&, Json::Value&)’:
>     src/jsonrpc_handler.cpp:208:25: error: ambiguous overload for 
> ‘operator[]’ in ‘root[i]’
>     /usr/local/include/json/value.h:322:14: note: candidates are: 
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>     /usr/local/include/json/value.h:329:14: note:                 
> Json::Value& Json::Value::operator[](int)
>     /usr/local/include/json/value.h:334:20: note:                 
> const Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) const
>     /usr/local/include/json/value.h:339:20: note:                 
> const Json::Value& Json::Value::operator[](int) const
>     src/jsonrpc_handler.cpp:213:23: error: ambiguous overload for 
> ‘operator[]’ in ‘response[j]’
>     /usr/local/include/json/value.h:322:14: note: candidates are: 
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>     /usr/local/include/json/value.h:329:14: note:                 
> Json::Value& Json::Value::operator[](int)
>     /usr/local/include/json/value.h:334:20: note:                 
> const Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) const
>     /usr/local/include/json/value.h:339:20: note:                 
> const Json::Value& Json::Value::operator[](int) const
>     scons: *** [src/jsonrpc_handler.os] Error 1
>     scons: building terminated because of errors.
>
> Here is `src/jsonrpc_handler.cpp` (I've marked lines 208 and 213):
>
>     /*
>      *  JsonRpc-Cpp - JSON-RPC implementation.
>      *  Copyright (C) 2008-2011 Sebastien Vincent 
> <seb...@cp...>
>      *
>      *  This program is free software: you can redistribute it and/or 
> modify
>      *  it under the terms of the GNU Lesser General Public License as 
> published by
>      *  the Free Software Foundation, either version 3 of the License, or
>      *  (at your option) any later version.
>      *
>      *  This program is distributed in the hope that it will be useful,
>      *  but WITHOUT ANY WARRANTY; without even the implied warranty of
>      *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>      *  GNU Lesser General Public License for more details.
>      *
>      *  You should have received a copy of the GNU Lesser General 
> Public License
>      *  along with this program.  If not, see 
> <http://www.gnu.org/licenses/>.
>      */
>
>     /**
>      * \file jsonrpc_handler.cpp
>      * \brief JSON-RPC server processor engine.
>      * \author Sebastien Vincent
>      */
>
>     #include "jsonrpc_handler.h"
>
>     namespace Json
>     {
>
>       namespace Rpc
>       {
>
>         CallbackMethod::~CallbackMethod()
>         {
>         }
>
>         Handler::Handler()
>         {
>           /* add a RPC method that list the actual RPC methods 
> contained in the Handler */
>           Json::Value root;
>
>           root["description"] = "List the RPC methods available";
>           root["parameters"] = Json::Value::null;
>           root["returns"] = "Object that contains description of all 
> methods registered";
>
>           AddMethod(new RpcMethod<Handler>(*this, 
> &Handler::SystemDescribe, std::string("system.describe"), root));
>         }
>
>         Handler::~Handler()
>         {
>           /* delete all objects from the list */
>           for(std::list<CallbackMethod*>::const_iterator it = 
> m_methods.begin() ; it != m_methods.end() ; it++)
>           {
>             delete (*it);
>           }
>           m_methods.clear();
>         }
>
>         void Handler::AddMethod(CallbackMethod* method)
>         {
>           m_methods.push_back(method);
>         }
>
>         void Handler::DeleteMethod(const std::string& name)
>         {
>           /* do not delete system defined method */
>           if(name == "system.describe")
>           {
>             return;
>           }
>
>           for(std::list<CallbackMethod*>::iterator it = 
> m_methods.begin() ; it != m_methods.end() ; it++)
>           {
>             if((*it)->GetName() == name)
>             {
>               delete (*it);
>               m_methods.erase(it);
>               break;
>             }
>           }
>         }
>
>         bool Handler::SystemDescribe(const Json::Value& msg, 
> Json::Value& response)
>         {
>           Json::Value methods;
>           response["jsonrpc"] = "2.0";
>           response["id"] = msg["id"];
>
>           for(std::list<CallbackMethod*>::iterator it = 
> m_methods.begin() ; it != m_methods.end() ; it++)
>           {
>             methods[(*it)->GetName()] = (*it)->GetDescription();
>           }
>
>           response["result"] = methods;
>           return true;
>         }
>
>         std::string Handler::GetString(Json::Value value)
>         {
>           return m_writer.write(value);
>         }
>
>         bool Handler::Check(const Json::Value& root, Json::Value& error)
>         {
>           Json::Value err;
>
>           /* check the JSON-RPC version => 2.0 */
>           if(!root.isObject() || !root.isMember("jsonrpc") || 
> root["jsonrpc"] != "2.0")
>           {
>             error["id"] = Json::Value::null;
>             error["jsonrpc"] = "2.0";
>
>             err["code"] = INVALID_REQUEST;
>             err["message"] = "Invalid JSON-RPC request.";
>             error["error"] = err;
>             return false;
>           }
>
>           if(root.isMember("id") && (root["id"].isArray() || 
> root["id"].isObject()))
>           {
>             error["id"] = Json::Value::null;
>             error["jsonrpc"] = "2.0";
>
>             err["code"] = INVALID_REQUEST;
>             err["message"] = "Invalid JSON-RPC request.";
>             error["error"] = err;
>             return false;
>           }
>
>           /* extract "method" attribute */
>           if(!root.isMember("method") || !root["method"].isString())
>           {
>             error["id"] = Json::Value::null;
>             error["jsonrpc"] = "2.0";
>
>             err["code"] = INVALID_REQUEST;
>             err["message"] = "Invalid JSON-RPC request.";
>             error["error"] = err;
>             return false;
>           }
>
>           return true;
>         }
>
>         bool Handler::Process(const Json::Value& root, Json::Value& 
> response)
>         {
>           Json::Value error;
>           std::string method;
>
>           if(!Check(root, error))
>           {
>             response = error;
>             return false;
>           }
>
>           method = root["method"].asString();
>
>           if(method != "")
>           {
>             CallbackMethod* rpc = Lookup(method);
>             if(rpc)
>             {
>               return rpc->Call(root, response);
>             }
>           }
>
>           /* forge an error response */
>           response["id"] = root.isMember("id") ? root["id"] : 
> Json::Value::null;
>           response["jsonrpc"] = "2.0";
>
>           error["code"] = METHOD_NOT_FOUND;
>           error["message"] = "Method not found.";
>           response["error"] = error;
>
>           return false;
>         }
>
>         bool Handler::Process(const std::string& msg, Json::Value& 
> response)
>         {
>           Json::Value root;
>           Json::Value error;
>           bool parsing = false;
>
>           /* parsing */
>           parsing = m_reader.parse(msg, root);
>
>           if(!parsing)
>           {
>             /* request or batched call is not in JSON format */
>             response["id"] = Json::Value::null;
>             response["jsonrpc"] = "2.0";
>
>             error["code"] = PARSING_ERROR;
>             error["message"] = "Parse error.";
>             response["error"] = error;
>             return false;
>           }
>
>           if(root.isArray())
>           {
>             /* batched call */
>             size_t i = 0;
>             size_t j = 0;
>
>             for(i = 0 ; i < root.size() ; i++)
>             {
>               Json::Value ret;
>               Process(root[i], ret);   //line 208!
>
>               if(ret != Json::Value::null)
>               {
>                 /* it is not a notification, add to array of responses */
>                 response[j] = ret;   //line 213!
>                 j++;
>               }
>             }
>             return true;
>           }
>           else
>           {
>             return Process(root, response);
>           }
>         }
>
>         bool Handler::Process(const char* msg, Json::Value& response)
>         {
>           std::string str(msg);
>
>           return Process(str, response);
>         }
>
>         CallbackMethod* Handler::Lookup(const std::string& name) const
>         {
>           for(std::list<CallbackMethod*>::const_iterator it = 
> m_methods.begin() ; it != m_methods.end() ; it++)
>           {
>             if((*it)->GetName() == name)
>             {
>               return (*it);
>             }
>           }
>
>           return 0;
>         }
>
>       } /* namespace Rpc */
>
>     } /* namespace Json */
>
> I'm really hoping someone might be able to point me in the right 
> direction.
>
> Many thanks in advance,
>
>
> ------------------------------------------------------------------------------
> BlackBerry&reg; DevCon Americas, Oct. 18-20, San Francisco, CA
> The must-attend event for mobile developers. Connect with experts.
> Get tools for creating Super Apps. See the latest technologies.
> Sessions, hands-on labs, demos&  much more. Register early&  save!
> http://p.sf.net/sfu/rim-blackberry-1
>
>
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

Re: [Jsonrpc-cpp-devel] Scons error: "ambiguous overload"

[Eamonn H. <eam...@al...>]

Hi,

Many thanks for the message.

I'm on Ubuntu Linux, 64-bit, g++ 4.5.2.

I think I've managed to solve this problem:

Here's what I did on lines 208 and 213 - I just casted the indexes:

Process(root[(Json::Value::ArrayIndex)i], ret); //line 208

response[(Json::Value::ArrayIndex)j] = ret; //line 213

Hope this helps,

Eamonn






----- Original Message -----
From: "Sebastien Vincent" <seb...@cp...>
To: "Eamonn Hynes" <eam...@al...>
Cc: jso...@li...
Sent: Monday, 8 August, 2011 5:14:26 PM
Subject: Re: [Jsonrpc-cpp-devel] Scons error: "ambiguous overload"

Hi,

What is your environment (OS, g++ version, jsoncpp version, ...) ?
 
--
Seb


On Mon, 8 Aug 2011 10:27:11 +0100 (IST), Eamonn Hynes
<eam...@al...> wrote:
> I hope someone can help me get jsonrpc-cpp to compile.
> 
> When I type `scons` as per the documentation, I get:
> 
>  eamorr@Compaq6000:~/Desktop/jsonrpc-cpp$ scons
>  scons: Reading SConscript files ...
>  scons: done reading SConscript files.
>  scons: Building targets ...
>  g++ -o src/jsonrpc_handler.os -c -std=c++98 -Wall -Wextra -pedantic
> -Wredundant-decls -Wshadow -Werror -O2 -fPIC src/jsonrpc_handler.cpp
>  src/jsonrpc_handler.cpp: In member function ‘bool
> Json::Rpc::Handler::Process(const std::string&, Json::Value&)’:
>  src/jsonrpc_handler.cpp:208:25: error: ambiguous overload for
> ‘operator[]’ in ‘root[i]’
>  /usr/local/include/json/value.h:322:14: note: candidates are:
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>  /usr/local/include/json/value.h:329:14: note: Json::Value&
> Json::Value::operator[](int)
>  /usr/local/include/json/value.h:334:20: note: const Json::Value&
> Json::Value::operator[](Json::Value::ArrayIndex) const
>  /usr/local/include/json/value.h:339:20: note: const Json::Value&
> Json::Value::operator[](int) const
>  src/jsonrpc_handler.cpp:213:23: error: ambiguous overload for
> ‘operator[]’ in ‘response[j]’
>  /usr/local/include/json/value.h:322:14: note: candidates are:
> Json::Value& Json::Value::operator[](Json::Value::ArrayIndex)
>  /usr/local/include/json/value.h:329:14: note: Json::Value&
> Json::Value::operator[](int)
>  /usr/local/include/json/value.h:334:20: note: const Json::Value&
> Json::Value::operator[](Json::Value::ArrayIndex) const
>  /usr/local/include/json/value.h:339:20: note: const Json::Value&
> Json::Value::operator[](int) const
>  scons: *** [src/jsonrpc_handler.os] Error 1
>  scons: building terminated because of errors.
> 
> Here is `src/jsonrpc_handler.cpp` (I've marked lines 208 and 213):
> 
>  /*
>  * JsonRpc-Cpp - JSON-RPC implementation.
>  * Copyright (C) 2008-2011 Sebastien Vincent 
>  *
>  * This program is free software: you can redistribute it and/or
> modify
>  * it under the terms of the GNU Lesser General Public License as
> published by
>  * the Free Software Foundation, either version 3 of the License, or
>  * (at your option) any later version.
>  *
>  * This program is distributed in the hope that it will be useful,
>  * but WITHOUT ANY WARRANTY; without even the implied warranty of
>  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
>  * GNU Lesser General Public License for more details.
>  *
>  * You should have received a copy of the GNU Lesser General Public
> License
>  * along with this program. If not, see .
>  */
> 
>  /**
>  * file jsonrpc_handler.cpp
>  * brief JSON-RPC server processor engine.
>  * author Sebastien Vincent
>  */
> 
>  #include "jsonrpc_handler.h"
> 
>  namespace Json
>  {
> 
>  namespace Rpc
>  {
> 
>  CallbackMethod::~CallbackMethod()
>  {
>  }
> 
>  Handler::Handler()
>  {
>  /* add a RPC method that list the actual RPC methods contained in
> the Handler */
>  Json::Value root;
> 
>  root["description"] = "List the RPC methods available";
>  root["parameters"] = Json::Value::null;
>  root["returns"] = "Object that contains description of all methods
> registered";
> 
>  AddMethod(new RpcMethod(*this, &Handler::SystemDescribe,
> std::string("system.describe"), root));
>  }
> 
>  Handler::~Handler()
>  {
>  /* delete all objects from the list */
>  for(std::list::const_iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  delete (*it);
>  }
>  m_methods.clear();
>  }
> 
>  void Handler::AddMethod(CallbackMethod* method)
>  {
>  m_methods.push_back(method);
>  }
> 
>  void Handler::DeleteMethod(const std::string& name)
>  {
>  /* do not delete system defined method */
>  if(name == "system.describe")
>  {
>  return;
>  }
> 
>  for(std::list::iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  if((*it)->GetName() == name)
>  {
>  delete (*it);
>  m_methods.erase(it);
>  break;
>  }
>  }
>  }
> 
>  bool Handler::SystemDescribe(const Json::Value& msg, Json::Value&
> response)
>  {
>  Json::Value methods;
>  response["jsonrpc"] = "2.0";
>  response["id"] = msg["id"];
> 
>  for(std::list::iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  methods[(*it)->GetName()] = (*it)->GetDescription();
>  }
> 
>  response["result"] = methods;
>  return true;
>  }
> 
>  std::string Handler::GetString(Json::Value value)
>  {
>  return m_writer.write(value);
>  }
> 
>  bool Handler::Check(const Json::Value& root, Json::Value& error)
>  {
>  Json::Value err;
> 
>  /* check the JSON-RPC version => 2.0 */
>  if(!root.isObject() || !root.isMember("jsonrpc") || root["jsonrpc"]
> != "2.0") 
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  if(root.isMember("id") && (root["id"].isArray() ||
> root["id"].isObject()))
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  /* extract "method" attribute */
>  if(!root.isMember("method") || !root["method"].isString())
>  {
>  error["id"] = Json::Value::null;
>  error["jsonrpc"] = "2.0";
> 
>  err["code"] = INVALID_REQUEST;
>  err["message"] = "Invalid JSON-RPC request.";
>  error["error"] = err;
>  return false;
>  }
> 
>  return true;
>  }
> 
>  bool Handler::Process(const Json::Value& root, Json::Value&
> response)
>  {
>  Json::Value error;
>  std::string method;
> 
>  if(!Check(root, error))
>  {
>  response = error;
>  return false;
>  }
> 
>  method = root["method"].asString();
> 
>  if(method != "")
>  {
>  CallbackMethod* rpc = Lookup(method);
>  if(rpc)
>  {
>  return rpc->Call(root, response);
>  }
>  }
> 
>  /* forge an error response */
>  response["id"] = root.isMember("id") ? root["id"] :
> Json::Value::null;
>  response["jsonrpc"] = "2.0";
> 
>  error["code"] = METHOD_NOT_FOUND;
>  error["message"] = "Method not found.";
>  response["error"] = error;
> 
>  return false;
>  }
> 
>  bool Handler::Process(const std::string& msg, Json::Value& response)
>  {
>  Json::Value root;
>  Json::Value error;
>  bool parsing = false;
> 
>  /* parsing */
>  parsing = m_reader.parse(msg, root);
> 
>  if(!parsing)
>  {
>  /* request or batched call is not in JSON format */
>  response["id"] = Json::Value::null;
>  response["jsonrpc"] = "2.0";
> 
>  error["code"] = PARSING_ERROR;
>  error["message"] = "Parse error.";
>  response["error"] = error; 
>  return false;
>  }
> 
>  if(root.isArray())
>  {
>  /* batched call */
>  size_t i = 0;
>  size_t j = 0;
> 
>  for(i = 0 ; i < root.size() ; i++)
>  {
>  Json::Value ret;
>  Process(root[i], ret); //line 208!
> 
>  if(ret != Json::Value::null)
>  {
>  /* it is not a notification, add to array of responses */
>  response[j] = ret; //line 213!
>  j++;
>  }
>  }
>  return true;
>  }
>  else
>  {
>  return Process(root, response);
>  }
>  }
> 
>  bool Handler::Process(const char* msg, Json::Value& response)
>  {
>  std::string str(msg);
> 
>  return Process(str, response);
>  }
> 
>  CallbackMethod* Handler::Lookup(const std::string& name) const
>  {
>  for(std::list::const_iterator it = m_methods.begin() ; it !=
> m_methods.end() ; it++)
>  {
>  if((*it)->GetName() == name)
>  {
>  return (*it);
>  }
>  }
> 
>  return 0;
>  }
> 
>  } /* namespace Rpc */
> 
>  } /* namespace Json */
> 
> I'm really hoping someone might be able to point me in the right
> direction.
> 
> Many thanks in advance,

[Jsonrpc-cpp-devel] Scons error: "ambiguous overload"

[Eamonn H. <eam...@al...>]

I hope someone can help me get jsonrpc-cpp to compile. 

When I type `scons` as per the documentation, I get: 

eamorr@Compaq6000:~/Desktop/jsonrpc-cpp$ scons 
scons: Reading SConscript files ... 
scons: done reading SConscript files. 
scons: Building targets ... 
g++ -o src/jsonrpc_handler.os -c -std=c++98 -Wall -Wextra -pedantic -Wredundant-decls -Wshadow -Werror -O2 -fPIC src/jsonrpc_handler.cpp 
src/jsonrpc_handler.cpp: In member function ‘bool Json::Rpc::Handler::Process(const std::string&, Json::Value&)’: 
src/jsonrpc_handler.cpp:208:25: error: ambiguous overload for ‘operator[]’ in ‘root[i]’ 
/usr/local/include/json/value.h:322:14: note: candidates are: Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) 
/usr/local/include/json/value.h:329:14: note: Json::Value& Json::Value::operator[](int) 
/usr/local/include/json/value.h:334:20: note: const Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) const 
/usr/local/include/json/value.h:339:20: note: const Json::Value& Json::Value::operator[](int) const 
src/jsonrpc_handler.cpp:213:23: error: ambiguous overload for ‘operator[]’ in ‘response[j]’ 
/usr/local/include/json/value.h:322:14: note: candidates are: Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) 
/usr/local/include/json/value.h:329:14: note: Json::Value& Json::Value::operator[](int) 
/usr/local/include/json/value.h:334:20: note: const Json::Value& Json::Value::operator[](Json::Value::ArrayIndex) const 
/usr/local/include/json/value.h:339:20: note: const Json::Value& Json::Value::operator[](int) const 
scons: *** [src/jsonrpc_handler.os] Error 1 
scons: building terminated because of errors. 

Here is `src/jsonrpc_handler.cpp` (I've marked lines 208 and 213): 

/* 
* JsonRpc-Cpp - JSON-RPC implementation. 
* Copyright (C) 2008-2011 Sebastien Vincent <seb...@cp...> 
* 
* This program is free software: you can redistribute it and/or modify 
* it under the terms of the GNU Lesser General Public License as published by 
* the Free Software Foundation, either version 3 of the License, or 
* (at your option) any later version. 
* 
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU Lesser General Public License for more details. 
* 
* You should have received a copy of the GNU Lesser General Public License 
* along with this program. If not, see <http://www.gnu.org/licenses/>. 
*/ 

/** 
* \file jsonrpc_handler.cpp 
* \brief JSON-RPC server processor engine. 
* \author Sebastien Vincent 
*/ 

#include "jsonrpc_handler.h" 

namespace Json 
{ 

namespace Rpc 
{ 

CallbackMethod::~CallbackMethod() 
{ 
} 

Handler::Handler() 
{ 
/* add a RPC method that list the actual RPC methods contained in the Handler */ 
Json::Value root; 

root["description"] = "List the RPC methods available"; 
root["parameters"] = Json::Value::null; 
root["returns"] = "Object that contains description of all methods registered"; 

AddMethod(new RpcMethod<Handler>(*this, &Handler::SystemDescribe, std::string("system.describe"), root)); 
} 

Handler::~Handler() 
{ 
/* delete all objects from the list */ 
for(std::list<CallbackMethod*>::const_iterator it = m_methods.begin() ; it != m_methods.end() ; it++) 
{ 
delete (*it); 
} 
m_methods.clear(); 
} 

void Handler::AddMethod(CallbackMethod* method) 
{ 
m_methods.push_back(method); 
} 

void Handler::DeleteMethod(const std::string& name) 
{ 
/* do not delete system defined method */ 
if(name == "system.describe") 
{ 
return; 
} 

for(std::list<CallbackMethod*>::iterator it = m_methods.begin() ; it != m_methods.end() ; it++) 
{ 
if((*it)->GetName() == name) 
{ 
delete (*it); 
m_methods.erase(it); 
break; 
} 
} 
} 

bool Handler::SystemDescribe(const Json::Value& msg, Json::Value& response) 
{ 
Json::Value methods; 
response["jsonrpc"] = "2.0"; 
response["id"] = msg["id"]; 

for(std::list<CallbackMethod*>::iterator it = m_methods.begin() ; it != m_methods.end() ; it++) 
{ 
methods[(*it)->GetName()] = (*it)->GetDescription(); 
} 

response["result"] = methods; 
return true; 
} 

std::string Handler::GetString(Json::Value value) 
{ 
return m_writer.write(value); 
} 

bool Handler::Check(const Json::Value& root, Json::Value& error) 
{ 
Json::Value err; 

/* check the JSON-RPC version => 2.0 */ 
if(!root.isObject() || !root.isMember("jsonrpc") || root["jsonrpc"] != "2.0") 
{ 
error["id"] = Json::Value::null; 
error["jsonrpc"] = "2.0"; 

err["code"] = INVALID_REQUEST; 
err["message"] = "Invalid JSON-RPC request."; 
error["error"] = err; 
return false; 
} 

if(root.isMember("id") && (root["id"].isArray() || root["id"].isObject())) 
{ 
error["id"] = Json::Value::null; 
error["jsonrpc"] = "2.0"; 

err["code"] = INVALID_REQUEST; 
err["message"] = "Invalid JSON-RPC request."; 
error["error"] = err; 
return false; 
} 

/* extract "method" attribute */ 
if(!root.isMember("method") || !root["method"].isString()) 
{ 
error["id"] = Json::Value::null; 
error["jsonrpc"] = "2.0"; 

err["code"] = INVALID_REQUEST; 
err["message"] = "Invalid JSON-RPC request."; 
error["error"] = err; 
return false; 
} 

return true; 
} 

bool Handler::Process(const Json::Value& root, Json::Value& response) 
{ 
Json::Value error; 
std::string method; 

if(!Check(root, error)) 
{ 
response = error; 
return false; 
} 

method = root["method"].asString(); 

if(method != "") 
{ 
CallbackMethod* rpc = Lookup(method); 
if(rpc) 
{ 
return rpc->Call(root, response); 
} 
} 

/* forge an error response */ 
response["id"] = root.isMember("id") ? root["id"] : Json::Value::null; 
response["jsonrpc"] = "2.0"; 

error["code"] = METHOD_NOT_FOUND; 
error["message"] = "Method not found."; 
response["error"] = error; 

return false; 
} 

bool Handler::Process(const std::string& msg, Json::Value& response) 
{ 
Json::Value root; 
Json::Value error; 
bool parsing = false; 

/* parsing */ 
parsing = m_reader.parse(msg, root); 

if(!parsing) 
{ 
/* request or batched call is not in JSON format */ 
response["id"] = Json::Value::null; 
response["jsonrpc"] = "2.0"; 

error["code"] = PARSING_ERROR; 
error["message"] = "Parse error."; 
response["error"] = error; 
return false; 
} 

if(root.isArray()) 
{ 
/* batched call */ 
size_t i = 0; 
size_t j = 0; 

for(i = 0 ; i < root.size() ; i++) 
{ 
Json::Value ret; 
Process(root[i], ret); //line 208! 

if(ret != Json::Value::null) 
{ 
/* it is not a notification, add to array of responses */ 
response[j] = ret; //line 213! 
j++; 
} 
} 
return true; 
} 
else 
{ 
return Process(root, response); 
} 
} 

bool Handler::Process(const char* msg, Json::Value& response) 
{ 
std::string str(msg); 

return Process(str, response); 
} 

CallbackMethod* Handler::Lookup(const std::string& name) const 
{ 
for(std::list<CallbackMethod*>::const_iterator it = m_methods.begin() ; it != m_methods.end() ; it++) 
{ 
if((*it)->GetName() == name) 
{ 
return (*it); 
} 
} 

return 0; 
} 

} /* namespace Rpc */ 

} /* namespace Json */ 

I'm really hoping someone might be able to point me in the right direction. 

Many thanks in advance, 

Re: [Jsonrpc-cpp-devel] Is this project still active?

[Sebastien V. <seb...@cp...>]

Hi,

For the moment I have currently no time to work on this project. But if
you want to contribute I will be glad to see what new
features/modifications you propose and I can review your patchs (before
giving you commit access).

Regards,
--
Seb

On Wed, 20 Jul 2011 23:50:09 +0200, Peter Spiess-Knafl
<pet...@gm...> wrote:
> Hey!
> 
> I am currently developing some kind of JSON-RPC Framework for C++ and
> recognized that this project is the only solution for C++.
> 
> Are you still working on this project? If yes, I would be interested to
> contribute to it, if no, I would start my own JSON-RPC Framework for C++.
> 
> 
> Regards
> Peter Knafl
> 
> ------------------------------------------------------------------------------
> 5 Ways to Improve & Secure Unified Communications
> Unified Communications promises greater efficiencies for business. UC can 
> improve internal communications as well as offer faster, more efficient ways
> to interact with customers and streamline customer service. Learn more!
> http://www.accelacomm.com/jaw/sfnl/114/51426253/
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

[Jsonrpc-cpp-devel] Is this project still active?

[Peter Spiess-K. <pet...@gm...>]

Hey!

I am currently developing some kind of JSON-RPC Framework for C++ and
recognized that this project is the only solution for C++.

Are you still working on this project? If yes, I would be interested to
contribute to it, if no, I would start my own JSON-RPC Framework for C++.


Regards
Peter Knafl

Re: [Jsonrpc-cpp-devel] over http

[Sebastien V. <seb...@cp...>]

Hi Victor,

Currently JsonRpc-cpp does not provide JSON-RPC over HTTP client. It
only provide UDP and TCP examples.

But maybe someone on the list has already implemented the HTTP layer.
In this case I will be glad to integrate it to the project.

Regards,
--
Sebastien Vincent

On Tue, 7 Jun 2011 22:53:16 +0300, Victor Sklyar <vi...@gm...>
wrote:
> hi!
> 
> Somebody can get me examply with jsonrpc-cpp over http client?
> 
> thx
> 
> ------------------------------------------------------------------------------
> EditLive Enterprise is the world's most technically advanced content
> authoring tool. Experience the power of Track Changes, Inline Image
> Editing and ensure content is compliant with Accessibility Checking.
> http://p.sf.net/sfu/ephox-dev2dev
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel

[Jsonrpc-cpp-devel] over http

[Victor S. <vi...@gm...>]

hi!

Somebody can get me examply with jsonrpc-cpp over http client?

thx

Re: [Jsonrpc-cpp-devel] how can I obtain client IP ?

[Sébastien V. <vi...@cl...>]

Hi Alexander,

Alexander Venin a écrit :
> I started JSON RPC TCP server, another JSON RPC client connected to the server. How can server obtain an IP address of connected client? As I see It's impossible: in function TcpServer::Accept call to "accept()" with sockaddr parameter set to 0 and no information about client has stored in list except of client's connected socket descriptor.
> May be I can fix this shortcoming ? I wish to store in list not only socket descriptor but client IP address.
>
>   

You can get client's sockaddr by calling getpeername() on the socket 
descriptor.

Regards,
--
Seb

> Thanks in advance, Alexander.
>
>
> ------------------------------------------------------------------------------
> Download Intel® Parallel Studio Eval
> Try the new software tools for yourself. Speed compiling, find bugs
> proactively, and fine-tune applications for parallel performance.
> See why Intel Parallel Studio got high marks during beta.
> http://p.sf.net/sfu/intel-sw-dev
> _______________________________________________
> Jsonrpc-cpp-devel mailing list
> Jso...@li...
> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel
>
>   

[Jsonrpc-cpp-devel] how can I obtain client IP ?

[Alexander V. <vav...@ma...>]

I started JSON RPC TCP server, another JSON RPC client connected to the server. How can server obtain an IP address of connected client? As I see It's impossible: in function TcpServer::Accept call to "accept()" with sockaddr parameter set to 0 and no information about client has stored in list except of client's connected socket descriptor.
May be I can fix this shortcoming ? I wish to store in list not only socket descriptor but client IP address.

Thanks in advance, Alexander.

[Jsonrpc-cpp-devel] JsonRpc-Cpp Licensing

[Anders D. <js...@da...>]

Hi,

Would it be possible to alter the license of JsonRpc-Cpp in future 
releases to LGPL, or possible support dual licensing of some kind?

I would gladly help to improve the library but currently I cannot even 
use the library due to it's GPL licensing and my company's policy about 
GPL licensed libraries.

Best regards,
Anders Dalvander

Re: [Jsonrpc-cpp-devel] HTTP encapsulation

[Eric B. <eri...@gm...>]

Good point on the multi threaded part.  I've attached my changes to
make the program able to accept multiple connections.  It's kind of a
lazy job, but it allows someone to just comment/uncomment out the one
line to go between multi and single connections.

As for  HTTP encapsulation, I'm not sure if I want it anymore ... a
simple php socket script can act as a HTTP front end, and this makes
the service a lot easier to maintain / configure.  Thoughts?

Thank you!
Eric



On Tue, Sep 29, 2009 at 5:12 AM, Sebastien Vincent
<seb...@cp...> wrote:
> Hi Eric,
>
> Just one things. When your answer on a mailing-list, please click "reply to
> all"...
>
> I want JsonRpc-Cpp project to stay simple and lightweight so I prefer to
> not have a library dependency such as Apache axis2.
>
> I know that "reinventing the wheel" could be painful, but I don't think it
> is too complicated to add HTTP header, manage some HTTP errors code... I
> heard about someone who wants to build multithreaded servers in JsonRpc-Cpp
> but never heard of him since many times.
>
> Regards,
> --
> Seb
>
>
> On Mon, 28 Sep 2009 10:34:16 -0700, Eric Berryman <eri...@gm...>
> wrote:
>> Do you think it would be better to build the whole thing on some sort
>> of engine, like apache axis2?
>> This would solve a lot of the connection issues; handling multiple
>> connections, various headers, etc.
>>
>> What do you think?
>>
>> Thank you!
>> Eric
>>
>>
>>
>> On Wed, Sep 23, 2009 at 8:23 PM, Sebastien Vincent
>> <seb...@cp...> wrote:
>>> Hi Eric,
>>>
>>> Eric Berryman a écrit :
>>>>
>>>> Hello!
>>>>
>>>> I'm interested in the HTTP encapsulation (and maybe adding some JSONP
>>>> support).  Has anyone started this?  I'm willing to work on this :)
>>>>
>>>>
>>>
>>> Nobody has begun this feature at my knowledge so go ahead :).
>>>
>>> Thanks to contribute to JsonRpc-Cpp.
>>>
>>> Regards,
>>> --
>>> Sebastien Vincent
>>>
>>>> Thank you!
>>>> Eric
>>>>
>>>>
>>>>
> ------------------------------------------------------------------------------
>>>> Come build with us! The BlackBerry® Developer Conference in SF, CA
>>>> is the only developer event you need to attend this year. Jumpstart
> your
>>>> developing skills, take BlackBerry mobile applications to market and
>>>> stay
>>>> ahead of the curve. Join us from November 9-12, 2009. Register
>>>> now!
>>>> http://p.sf.net/sfu/devconf
>>>> _______________________________________________
>>>> Jsonrpc-cpp-devel mailing list
>>>> Jso...@li...
>>>> https://lists.sourceforge.net/lists/listinfo/jsonrpc-cpp-devel
>>>>
>>>
>>>
>>>
>