Re: [Savannah-dev] debian packaging and protocol thoughts

[Guillaume Morin]

Dans un message du 29 nov à 14:33, Roland Mas écrivait :
>   Basically, the XML approach is a "stop all, dump all data, transfer
> all data, reload all data, restart" approach.  If things are done
> right, you can do it without stopping and restarting, but that still
> leaves three steps to handle.  That means *plenty* of code to do:
> write the XML from the source database, transfer it, then parse it and
> transform it into your internal object representation before inserting
> it back into the destination database.

We see the problem from a different point of view. XML has been chosen
for data representation (again for some obvious reasons simple API
available in a lot of langages and so on).

The rest is arbitrary choices. But look more closely on what we have to
implement.

- CoopX compatibility
- Way of communication
- Parsing information/Tranform it (to reuse your terms)

The first one implies to code some dumps scripts.
The last one is mandatory whatever technology you choose and I am pretty
sure that the complexity is almost the same whatever layer you have
above.

The second one is indeed a problem. We already said that. The current
one is just very simple but works.

I am sorry but I do think that our choices aim to simplicity.

>   My suggestion (CORBA) limits the amount of code to be written.
> Basically, it means that instead of dumping, transferring and
> reloading all the data, you update it by an RPC call of the like of
> "update this object with these data" (or, "give me the data
> corresponding to this object", depending on how you choose to do it).
> This can be done either daily for a bunch of objects, or in real-time
> (update the mirror object as soon as the main one is changed).

This way of communication seems appropriate.

>   At some point, you'll also need to check for return codes, or get
> bidirectional communication.  Exceptions.  Inheritance.  Whatever.

It seems that you did not have time to look at the code, we already have
that.

> Want to hand-code everything in XML?

XML is just a data representation, nothing else. You mix data and the
ways to propagate it.

>   I'm not saying that CORBA would solve all problems, obviously.  You
> would still have to code the methods, manage permissions, locks and
> concurrency, for a start.  But I think for what Savannah aims at
> becoming (I seem to remember the word "distributed" in some email or
> other), using a hand-coded transmission channel means spending way too
> much time and code in doing it, leaving too little for the actual
> logic of the application.  I much prefer wrapping my object.method()
> in a try...catch block than having to make sure the rsync worked
> correctly and the import of the data went OK, and retry everything if
> anything failed.  Much better control of your granularity, for one
> thing, and no need to hand-code the exception handling.

Granted. But we'd really need some code help since at this state of the
project, we cannot choose to use a technology we do not master.

>   On the other hand, even if (as you imply) XML dumps have been chosen
> and agreed upon, I think CORBA would provide a better communication
> layer than rsync.  It would remove the need for an external program,
> for a start, and you could customise error codes and exceptions, add
> feedback, logging, whatever.

Yes, we agreed on that point. Imho the moment when anyone posts some
plans is the best time to discuss this kind of issue.

The drawbacks of our current choice are the delay (but it is not that
important), and errors handling which exists but is not optimal compared
to CORBA. Its advantage is simplicity.

This is why I think they are not bad choices for a first version.

>   Now you do whatever you feel like, of course.  Should you go the
> CORBA way, feel free to ask for further advice, I'll be glad to
> provide it (as far as I can).

Unfortunately, to implement some CORBA things, we'd need some code too
at least to do some copy/paste :-) Do you have some useful pointers ?

Regards,

-- 
Guillaume Morin <address@hidden>

                             La vie est facétieuse