Hi,
i'd like to outline some needs i have for execnet
as well as propossing some rough sketchouts of possible solution
py.execnet between python2 and python3
--------------------------------------
This arises as i want to use anyvc in python3 while the backends are not
portable to python3 yet.
However syntax differences make normal interaction hard
and will most likely perfectly destroy the zero install mechanisms.
installing more complex dependencies in virtualenvs and reusing those
---------------------------------------------------------------------
Syntax differences between python versions as well as complex package
dependencies mandate installing some packages on the remote side.
Tools like virtualenv help with installing those separate from the
normal system as well as with limited rights.
However those tools might need some bootstraping outside of python as
the remote might not be ready to just start up a execnet slave.
a simple remote object protocol via wrappers around channels
------------------------------------------------------------
Inventing own protocols on top of channels if one want's to controll
remote-objects is a fragile task,
helper classes to ease the process are very welcome.
the proposed solutions
-----------------------
1. gw.remote_call(remote_callable, *k, **kw) as alternative to
gw.remote_exec(code)
* import the callable remote_callable on the remote
* call remote_callable(channel, *k, **kw)
where channel is the usual remote_channel
2. a virtualenv based minimal install system
it needs to do without a usable remote python
(ie wrong platform, whatever):
* create a virtualenv at a given path
* install something like a minimal py.execnet slave,
so the remote side can be started
* all other install operations should be controllable
via some kind of remote_exec/remote_call
3. RemoteCaller/RemoteHandler as wrappers around channels that represent
remote objects
* a experiment in anyvc
* currently lacks a way to propperly document remote methods
* RemoteCaller is a base class for wrappers
that call to remote objects via a channel
object.method(*k, **kw) translates to
channel.send(('method', k, kw))
return channel.receive()
the default handling can be overridden by implementing own methods
the method self._call_method(name, k, kw) ma
* RemoteHandler is a base class for Channel callbacks
once can use as convience wrapper around remote objects
in order too ease handling messages
for each incoming method, k, kw tuple
it calls the method on self,
unpacking the arguments
_______________________________________________
py-dev mailing list
py-dev@codespeak.net
http://codespeak.net/mailman/listinfo/py-dev
