docs: def run_via_binary(self, run_command_instance=None, command=None, volumes=None,
                         additional_opts=None, **kwargs):
          """
          create a container using this image and run it in background;
          this method is useful to test real user scenarios when users invoke containers using
          binary
  
          :param run_command_instance: instance of PodmanRunBuilder
          :param command: list of str, command to run in the container, examples:
              - ["ls", "/"]
              - ["bash", "-c", "ls / | grep bin"]
          :param volumes: tuple or list of tuples in the form:
  
              * `("/path/to/directory", )`
              * `("/host/path", "/container/path")`
              * `("/host/path", "/container/path", "mode")`
              * `(conu.Directory('/host/path'), "/container/path")` (source can be also
                  Directory instance)
  
          :param additional_opts: list of str, additional options for `podman run`
          :return: instance of PodmanContainer
          """
  
          logger.info("run container via binary in background")
  
          if (command is not None or additional_opts is not None) \
                  and run_command_instance is not None:
              raise ConuException(
                  "run_command_instance and command parameters cannot be passed "
                  "into method at same time")
  
          if run_command_instance is None:
              command = command or []
              additional_opts = additional_opts or []
  
              if (isinstance(command, list) or isinstance(command, tuple) and
                 isinstance(additional_opts, list) or isinstance(additional_opts, tuple)):
                  run_command_instance = PodmanRunBuilder(
                      command=command, additional_opts=additional_opts)
              else:
                  raise ConuException("command and additional_opts needs to be list of str or None")
          else:
              run_command_instance = run_command_instance or PodmanRunBuilder()
              if not isinstance(run_command_instance, PodmanRunBuilder):
                  raise ConuException(
                      "run_command_instance needs to be an instance of PodmanRunBuilder")
  
          run_command_instance.image_name = self.get_id()
          run_command_instance.options += ["-d"]
  
          if volumes:
              run_command_instance.options += self.get_volume_options(volumes=volumes)
  
          def callback():
              try:
                  # FIXME: catch std{out,err}, print stdout to logger.debug, stderr to logger.error
                  run_cmd(run_command_instance.build())
              except subprocess.CalledProcessError as ex:
                  raise ConuException("Container exited with an error: %s" % ex.returncode)
  
          container_id, _ = self._run_container(run_command_instance, callback)
          container_name = graceful_get(self._inspect(container_id), "Name")
  
          return PodmanContainer(self, container_id, name=container_name)