Passing objects to a Service

[botev]

Sorry, as this not nesscarily a bug, but currently I did not manage to find anyway of passing an external object to a service, except via global variables.
Technically I want something like this:

class ClusterService(Service):
    def __init__(self, conn, lock: RLock, cluster: Cluster):
        super(ClusterService, self).__init__(conn)
        self.lock: RLock = lock
        self.cluster: Cluster = cluster

    def print_stats(self, project, status, print_pool):
        with self.lock:
            self.cluster.print_stats(project, status, print_pool)

    def submit_job(self, project, name, command, res_file, out_file, err_file, priority=None):
        with self.lock:
            self.cluster.submit_job(project, name, command,
                                    res_file, out_file, err_file, priority)

    def delete_job(self, project, names_or_uids):
        with self.lock:
            for name_or_uid in names_or_uids:
                self.cluster.delete_job(project, name_or_uid)

The issue is that there is no way to pass a partially constructed object to the ThreadedServer. Is there any work around this?

[coldfix]

Hi,

up to 3.4 probably the simplest option is to pass parameters via the config dictionary that will be available via self._conn._config.

otherwise, you could do it like this, e.g.:

class FooService(rpyc.Service):
  def __init__(self, conn, lock, cluster):
    super().__init__(conn)
    self.lock = lock
    self.cluster = cluster
  def __call__(self, conn):
    return self.__class__(conn, self.lock, self.cluster)

server = rpyc.ThreadedServer(FooService(None, Lock(), cluster))

If you handle only a single connection (e.g. OneShotServer, or connect methods), you could do it better like this:

class FooService(rpyc.Service):
  def __init__(self, lock, cluster):
    self.lock = lock
    self.cluster = cluster
  def __call__(self, conn):
    super().__init__(conn)
    return self

server = rpyc.ThreadedServer(FooService(Lock(), cluster))

(which acts similar to binding arguments)

or more properly separating the individual responsibilities:

class FooFactory:
  def __init__(self, lock, cluster):
    self._conn = None
    self.lock = lock
    self.cluster = cluster
  def get_service_name(self):
    return "FOO"
  def get_service_aliases(self):
    return ("FOO",)
  def __call__(self, conn):
    return FooService(conn, self.lock, self.cluster)

class FooService(rpyc.Service):
  def __init__(self, conn, lock, cluster):
    super().__init__(conn)
    self.lock = lock
    self.cluster = cluster

server = rpyc.ThreadedServer(FooFactory(Lock(), cluster))

I agree, that this is poorly separated, rpyc.Service serves two different purposes (Factory + Service object) and I'm open for fixing this.

[botev]

So I'm fine with using your solution. As a long-term might be worth to make the ThreadServrer accept kwargs which are passed to the Service object, to make this cleaner.

[coldfix]

Hi, my recommended solution as of now is to use:

def classpartial(*args, **kwargs):
    """Bind arguments to a class's __init__."""
    cls, args = args[0], args[1:]
    class Partial(cls):
        __doc__ = cls.__doc__
        def __new__(self):
            return cls(*args, **kwargs)
    Partial.__name__ = cls.__name__
    return Partial

server = rpyc.ThreadedServer(classpartial(FooService, Lock(), cluster))

This function will also be available as rpyc.utils.helpers.classpartial in the upcoming release.

However, also note that the connection will not be passed to Service.__init__ anymore in the next release! Instead, you get it as on_connect(self, conn).

Best, Thomas

[botev]

I guess when you switch fully to on_connect than we can just pass the already constructed object directly. Thanks for the feedback.

[coldfix]

That's true only if you either serve only a single connection (e.g. as client or OneShotServer) or if want to use the same service object for the all your clients.