docs: def MakeDeployableBinary(self, template_path, output_path):
      """This will add the config to the client template and create a .rpm."""
  
      rpmbuild_binary = "/usr/bin/rpmbuild"
      if not os.path.exists(rpmbuild_binary):
        logging.error("rpmbuild not found, unable to repack client.")
        return
  
      with utils.TempDirectory() as tmp_dir:
        template_dir = os.path.join(tmp_dir, "dist")
        utils.EnsureDirExists(template_dir)
  
        zf = zipfile.ZipFile(template_path)
        for name in zf.namelist():
          dirname = os.path.dirname(name)
          utils.EnsureDirExists(os.path.join(template_dir, dirname))
          with open(os.path.join(template_dir, name), "wb") as fd:
            fd.write(zf.read(name))
  
        # Set up a RPM building environment.
  
        rpm_root_dir = os.path.join(tmp_dir, "rpmbuild")
  
        rpm_build_dir = os.path.join(rpm_root_dir, "BUILD")
        utils.EnsureDirExists(rpm_build_dir)
  
        rpm_buildroot_dir = os.path.join(rpm_root_dir, "BUILDROOT")
        utils.EnsureDirExists(rpm_buildroot_dir)
  
        rpm_rpms_dir = os.path.join(rpm_root_dir, "RPMS")
        utils.EnsureDirExists(rpm_rpms_dir)
  
        rpm_specs_dir = os.path.join(rpm_root_dir, "SPECS")
        utils.EnsureDirExists(rpm_specs_dir)
  
        template_binary_dir = os.path.join(tmp_dir, "dist/rpmbuild/grr-client")
  
        target_binary_dir = "%s%s" % (
            rpm_build_dir,
            config.CONFIG.Get("ClientBuilder.target_dir", context=self.context))
  
        utils.EnsureDirExists(os.path.dirname(target_binary_dir))
        try:
          shutil.rmtree(target_binary_dir)
        except OSError:
          pass
        # TODO(user):pytype: incorrect move() definition in typeshed.
        # pytype: disable=wrong-arg-types
        shutil.move(template_binary_dir, target_binary_dir)
        # pytype: enable=wrong-arg-types
  
        client_name = config.CONFIG.Get("Client.name", context=self.context)
        client_binary_name = config.CONFIG.Get(
            "Client.binary_name", context=self.context)
        if client_binary_name != "grr-client":
          # TODO(user):pytype: incorrect move() definition in typeshed.
          # pytype: disable=wrong-arg-types
          shutil.move(
              os.path.join(target_binary_dir, "grr-client"),
              os.path.join(target_binary_dir, client_binary_name))
          # pytype: enable=wrong-arg-types
  
        if config.CONFIG.Get("Client.fleetspeak_enabled", context=self.context):
          self._GenerateFleetspeakConfig(template_dir, rpm_build_dir)
          if not config.CONFIG.Get(
              "Client.fleetspeak_service_name", context=self.context):
            # The Fleetspeak service name is required when generating the RPM
            # spec file.
            raise BuildError("Client.fleetspeak_service_name is not set.")
        else:
          self._GenerateInitConfigs(template_dir, rpm_build_dir)
  
        # Generate spec
        spec_filename = os.path.join(rpm_specs_dir, "%s.spec" % client_name)
        self.GenerateFile(
            os.path.join(tmp_dir, "dist/rpmbuild/grr.spec.in"), spec_filename)
  
        # Generate prelinking blacklist file
        prelink_target_filename = os.path.join(rpm_build_dir,
                                               "etc/prelink.conf.d",
                                               "%s.conf" % client_name)
  
        utils.EnsureDirExists(os.path.dirname(prelink_target_filename))
        self.GenerateFile(
            os.path.join(tmp_dir, "dist/rpmbuild/prelink_blacklist.conf.in"),
            prelink_target_filename)
  
        # Create a client config.
        client_context = ["Client Context"] + self.context
        client_config_content = self.GetClientConfig(client_context)
  
        with open(
            os.path.join(
                target_binary_dir,
                config.CONFIG.Get(
                    "ClientBuilder.config_filename", context=self.context)),
            "wb") as fd:
          fd.write(client_config_content)
  
        # Set the daemon to executable.
        os.chmod(os.path.join(target_binary_dir, client_binary_name), 0o755)
  
        client_arch = config.CONFIG.Get("Template.arch", context=self.context)
        if client_arch == "amd64":
          client_arch = "x86_64"
  
        command = [
            rpmbuild_binary, "--define", "_topdir " + rpm_root_dir, "--target",
            client_arch, "--buildroot", rpm_buildroot_dir, "-bb", spec_filename
        ]
        try:
          subprocess.check_output(command, stderr=subprocess.STDOUT)
        except subprocess.CalledProcessError as e:
          logging.error("Error calling %s.", command)
          logging.error(e.output)
          raise
  
        client_version = config.CONFIG.Get(
            "Template.version_string", context=self.context)
        rpm_filename = os.path.join(
            rpm_rpms_dir, client_arch,
            "%s-%s-1.%s.rpm" % (client_name, client_version, client_arch))
  
        utils.EnsureDirExists(os.path.dirname(output_path))
        shutil.move(rpm_filename, output_path)
  
        logging.info("Created package %s", output_path)
        self.Sign(output_path)
        return output_path