docs: def spawn(self, aid, klass, *param, **kparam):
          '''
          This method creates an actor attached to this host. It will be
          an instance of the class *klass* and it will be assigned an ID
          that identifies it among the host.
  
          This method can be called remotely synchronously.
  
          :param str. aid: identifier for the spawning actor. Unique within
              the host.
          :param class klass: class type of the spawning actor. If you are
              spawning remotely and the class is not in the server module,
              you must specify here the path to that class in the form
              'module.py/Class' so the server can import the class and create
              the instance.
          :param param-kparam: arguments for the init function of the
              spawning actor class.
          :return: :class:`~.Proxy` of the actor spawned.
          :raises: :class:`AlreadyExistsError`, if the ID specified is
              already in use.
          :raises: :class:`HostDownError` if the host is not initiated.
          '''
          if param is None:
              param = []
          if not self.alive:
              raise HostDownError()
          if isinstance(klass, basestring):
              module, klass = klass.split('/')
              module_ = __import__(module, globals(), locals(),
                                   [klass], -1)
              klass_ = getattr(module_, klass)
          elif isinstance(klass, (types.TypeType, types.ClassType)):
              klass_ = klass
          url = '%s://%s/%s' % (self.transport, self.host_url.netloc, aid)
          if url in self.actors.keys():
              raise AlreadyExistsError(url)
          else:
              obj = klass_(*param, **kparam)
              obj.id = aid
              obj.url = url
              if self.running:
                  obj.host = self.proxy
              # else:
              #     obj.host = Exception("Host is not an active actor. \
              #                           Use 'init_host' to make it alive.")
  
              if hasattr(klass_, '_parallel') and klass_._parallel:
                  new_actor = parallels.ActorParallel(url, klass_, obj)
                  lock = new_actor.get_lock()
                  self.locks[url] = lock
              else:
                  new_actor = actor.Actor(url, klass_, obj)
  
              obj.proxy = Proxy(new_actor)
              self.launch_actor(url, new_actor)
              return Proxy(new_actor)