The most important thing to get worked out for this is the memory
management semantics between C and Ruby. From what I can tell from your
branch, it looks like you haven't done that yet.

As I've said before, the first step to wrapping the engine API is to work
out a simple strategy for wrapping C objects from the host language. In the
case of python this is done with the mixin. It uses various
python hooks as well as elements of python's C extension API to allow C
objects to hold references to python objects and keep them alive according
to python's memory management semantics. Just translating this wrapper code
from python to ruby won't do much good as Ruby's memory management
semantics are different and it's C extension API is different.

The first step you should take before bothering to wrap any code is to
figure out how you can have C objects hold pointers to ruby objects without
either incurring memory leaks or seg faults. Judging from what you've done
in ruby.i:

+ static void pn_rbref_incref(void *object) {  + // no reference counting
in Ruby  + }  +  + static void pn_rbref_decref(void *object) {  + // no
reference counting in Ruby  + }  +  + static int pn_rbref_refcount(void
*object) {  + return 1;  + }  +  + static const pn_class_t
*pn_rbref_reify(void *object) {  + return PN_RBREF;  + }

I suspect if you were to actually try anything significant you would incur
either seg faults or memory leaks or both, depending on precisely how Ruby
GC works. The excerpt from your branch above is creating a class of pointer
that will lie to proton and tell it that it always has a reference when it
doesn't really, and yet also lie to the Ruby VM because it is keeping a
pointer to a Ruby object without any way for the Ruby GC mechanism to be

I recommend starting with a very simple test case for one object, i.e.
define a wrapper mixin for ruby and use it to wrap just one proton object,
e.g. Connection. Don't bother with wrapping any of the methods on
Connection, all you really want to do is verify that object
creation/deletion works properly. Once you've done that you can run
creation/deletion in a  loop and verify that you don't leak memory. Before
this though, you'll need to read up on Ruby's C extension API in order to
figure out how to interface to it's memory management system so that the C
objects can hold pointers to Ruby objects and actually keep them alive, and
also free them when the C objects go away. Until you can do this and get
the basic loop test working with a simple object, there isn't really much
point in trying to wrap anything else.


On Wed, Jan 21, 2015 at 2:22 PM, Darryl L. Pierce <>

> I've been working on providing the low-level engine APIs in Ruby over
> the past few weeks, and from what I can see I think I'm near to
> completion regarding wrapping them.
> However, I'm not sure if I'm missing something since I don't see a way
> to use the code to create a connection. :D
> Specifically, what I want to do next is create examples of working with
> these low-level APIs, initially a simple send/receive example would be
> best with a receiver that listens for a connection and a sender that
> connects to it, all while being able to toggle tracing the
> communication, etc. I see nothing existing for other languages to use as
> a guide, so am a little stumped at the moment.
> The work I've done to date is here:
> --
> Darryl L. Pierce, Sr. Software Engineer @ Red Hat, Inc.
> Delivering value year after year.
> Red Hat ranks #1 in value among software vendors.

Reply via email to