mdl_pack.c

Go to the documentation of this file.

#include "mdl_pack.h"
 
#include <stdint.h>
#include <stdio.h>
 
#include "mdl_export.h"
#include "mdl_fetch.h"
#include "mdl_fetch_internal.h"
#include "mdl_sanitize.h"
#include "mdl_stream_internal.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

typedef enum : uint16_t {
  k_pack_leaf_bytes = 256,  
  k_pack_dir_bytes  = 1024, 
} mdl_pack_size_t;

RA8_INTERNAL static ra8_err_t internal_pack_text3(ra8_io_stream_t* stream,
                                                  const char*      first,
                                                  const char*      second,
                                                  const char*      third)
{
  ra8_err_t error = priv_mdl_stream_text(k_ra8_ok, stream, first);
  error           = priv_mdl_stream_text(error, stream, second);
  return priv_mdl_stream_text(error, stream, third);
}

RA8_INTERNAL static bool internal_pack_snprintf_fit(int n, size_t cap)
{
  return (n >= 0) && ((size_t)n < cap);
}

RA8_INTERNAL static mdl_export_meta_t
internal_pack_metadata(mdl_storage_t* storage, const mdl_export_meta_t* meta, const char* dir)
{
  mdl_export_meta_t selected;
  if (meta != nullptr) {
    selected = *meta;
  } else {
    (void)mdl_meta_load_dir(storage, &selected, dir);
  }
  return selected;
}

RA8_INTERNAL static void internal_pack_report_failure(ra8_io_stream_t* diagnostic,
                                                      const char*      chap_id,
                                                      const char*      ext,
                                                      ra8_err_t        rc)
{
  ra8_err_t output_error = internal_pack_text3(diagnostic, "  export ", chap_id, ".");
  output_error           = priv_mdl_stream_text(output_error, diagnostic, ext);
  output_error           = priv_mdl_stream_text(output_error, diagnostic, " FAILED (err 0x");
  output_error           = priv_mdl_stream_hex(output_error, diagnostic, (uint32_t)rc);
  (void)priv_mdl_stream_text(output_error, diagnostic, ")\n");
}

RA8_INTERNAL static size_t internal_pack_dir_output(mdl_storage_t*           storage,
                                                    mdl_format_t             format,
                                                    const char*              dir,
                                                    const char*              chap_id,
                                                    const char*              ext,
                                                    const mdl_export_meta_t* meta,
                                                    mdl_export_workspace_t*  ws,
                                                    ra8_io_stream_t*         output,
                                                    ra8_io_stream_t*         diagnostic)
{
  const ra8_err_t drc = mdl_export_chapter_meta_ws(storage, format, dir, dir, meta, ws);
  if (drc != k_ra8_ok) {
    internal_pack_report_failure(diagnostic, chap_id, ext, drc);
    return 1U;
  }
  ra8_err_t output_error = internal_pack_text3(output, "  converted ", chap_id, " -> ");
  output_error           = priv_mdl_stream_text(output_error, output, dir);
  output_error           = priv_mdl_stream_text(output_error, output, "/*.");
  output_error           = priv_mdl_stream_text(output_error, output, ext);
  output_error           = priv_mdl_stream_text(output_error, output, "\n");
  return (output_error == k_ra8_ok) ? 0U : 1U;
}
 
size_t mdl_pack_one_meta(mdl_storage_t*           storage,
                         mdl_format_t             format,
                         const char*              series_dir,
                         const char*              chap_id,
                         const mdl_export_meta_t* meta,
                         mdl_export_workspace_t*  ws,
                         ra8_io_stream_t*         output,
                         ra8_io_stream_t*         diagnostic)
{
  const char* ext = mdl_format_ext(format);
  char        dir[k_pack_dir_bytes];
  if (!mdl_path_join(series_dir, chap_id, dir, sizeof(dir))) {
    (void)internal_pack_text3(diagnostic, "  export ", chap_id, ".");
    (void)internal_pack_text3(diagnostic, "", ext, " path rejected, skipped\n");
    return 1U;
  }
 
  const mdl_export_meta_t m = internal_pack_metadata(storage, meta, dir);
 
  if (mdl_format_is_dir_output(format)) {
    return internal_pack_dir_output(storage, format, dir, chap_id, ext, &m, ws, output, diagnostic);
  }
  char      leaf[k_pack_leaf_bytes];
  const int ln = snprintf(leaf, sizeof(leaf), "%s.%s", chap_id, ext);
  char      out[k_pack_dir_bytes];
  if (!internal_pack_snprintf_fit(ln, sizeof(leaf)) ||
      !mdl_path_join(series_dir, leaf, out, sizeof(out))) {
    ra8_err_t output_error = internal_pack_text3(diagnostic, "  export ", chap_id, ".");
    output_error           = priv_mdl_stream_text(output_error, diagnostic, ext);
    (void)priv_mdl_stream_text(output_error, diagnostic, " path rejected, skipped\n");
    return 1U;
  }
  const ra8_err_t rc = mdl_export_chapter_meta_ws(storage, format, dir, out, &m, ws);
  if (rc != k_ra8_ok) {
    internal_pack_report_failure(diagnostic, chap_id, ext, rc);
    return 1U;
  }
  ra8_err_t output_error = internal_pack_text3(output, "  packaged ", chap_id, ".");
  output_error           = priv_mdl_stream_text(output_error, output, ext);
  output_error           = priv_mdl_stream_text(output_error, output, "\n");
  return (output_error == k_ra8_ok) ? 0U : 1U;
}
 
size_t mdl_pack_one(mdl_storage_t*          storage,
                    mdl_format_t            format,
                    const char*             series_dir,
                    const char*             chap_id,
                    mdl_export_workspace_t* ws,
                    ra8_io_stream_t*        output,
                    ra8_io_stream_t*        diagnostic)
{
  return mdl_pack_one_meta(storage, format, series_dir, chap_id, nullptr, ws, output, diagnostic);
}

RA8_INTERNAL static void internal_pack_report_combine_failure(ra8_io_stream_t* diagnostic,
                                                              ra8_err_t        rc)
{
  ra8_err_t output_error =
    priv_mdl_stream_text(k_ra8_ok, diagnostic, "  combine export FAILED (err 0x");
  output_error = priv_mdl_stream_hex(output_error, diagnostic, (uint32_t)rc);
  (void)priv_mdl_stream_text(output_error, diagnostic, ")\n");
}

RA8_INTERNAL static size_t internal_pack_combined_dir_output(mdl_storage_t*           storage,
                                                             mdl_format_t             format,
                                                             const char*              dir,
                                                             const char*              ext,
                                                             const char*              mark,
                                                             const mdl_export_meta_t* meta,
                                                             mdl_export_workspace_t*  ws,
                                                             ra8_io_stream_t*         output,
                                                             ra8_io_stream_t*         diagnostic)
{
  const ra8_err_t drc = mdl_export_chapter_meta_ws(storage, format, dir, dir, meta, ws);
  if (drc != k_ra8_ok) {
    internal_pack_report_combine_failure(diagnostic, drc);
    return 1U;
  }
  ra8_err_t output_error = internal_pack_text3(output, "  combined", mark, " -> ");
  output_error           = priv_mdl_stream_text(output_error, output, dir);
  output_error           = priv_mdl_stream_text(output_error, output, "/*.");
  output_error           = priv_mdl_stream_text(output_error, output, ext);
  output_error           = priv_mdl_stream_text(output_error, output, "\n");
  return (output_error == k_ra8_ok) ? 0U : 1U;
}

RA8_INTERNAL static size_t internal_pack_combined_dir(mdl_storage_t*           storage,
                                                      mdl_format_t             format,
                                                      const char*              series_dir,
                                                      const char*              combined_rel,
                                                      bool                     incomplete,
                                                      const mdl_export_meta_t* meta,
                                                      mdl_export_workspace_t*  ws,
                                                      ra8_io_stream_t*         output,
                                                      ra8_io_stream_t*         diagnostic)
{
  const char* ext  = mdl_format_ext(format);
  const char* mark = incomplete ? " (INCOMPLETE)" : "";
  char        dir[k_pack_dir_bytes];
  if (!mdl_path_join(series_dir, combined_rel, dir, sizeof(dir))) {
    (void)
      internal_pack_text3(diagnostic, "  combine export path rejected under ", series_dir, "\n");
    return 1U;
  }
 
  const mdl_export_meta_t m = internal_pack_metadata(storage, meta, dir);
 
  if (mdl_format_is_dir_output(format)) {
    return internal_pack_combined_dir_output(storage,
                                             format,
                                             dir,
                                             ext,
                                             mark,
                                             &m,
                                             ws,
                                             output,
                                             diagnostic);
  }
  char      leaf[k_pack_leaf_bytes];
  const int ln = incomplete ? snprintf(leaf, sizeof(leaf), "%s.INCOMPLETE.%s", combined_rel, ext)
                            : snprintf(leaf, sizeof(leaf), "%s.%s", combined_rel, ext);
  char      out[k_pack_dir_bytes];
  if (!internal_pack_snprintf_fit(ln, sizeof(leaf)) ||
      !mdl_path_join(series_dir, leaf, out, sizeof(out))) {
    (void)
      internal_pack_text3(diagnostic, "  combine export path rejected under ", series_dir, "\n");
    return 1U;
  }
  const ra8_err_t rc = mdl_export_chapter_meta_ws(storage, format, dir, out, &m, ws);
  if (rc != k_ra8_ok) {
    internal_pack_report_combine_failure(diagnostic, rc);
    return 1U;
  }
  ra8_err_t output_error = internal_pack_text3(output, "  combined", mark, " -> ");
  output_error           = priv_mdl_stream_text(output_error, output, out);
  output_error           = priv_mdl_stream_text(output_error, output, "\n");
  return (output_error == k_ra8_ok) ? 0U : 1U;
}
 
size_t mdl_pack_combined_meta(mdl_storage_t*           storage,
                              mdl_format_t             format,
                              bool                     allow_incomplete,
                              const char*              series_dir,
                              const char*              combined_rel,
                              const mdl_fetch_stats_t* stats,
                              const mdl_export_meta_t* meta,
                              mdl_export_workspace_t*  ws,
                              ra8_io_stream_t*         output,
                              ra8_io_stream_t*         diagnostic)
{
  if (stats->chapters_completed == 0U) {
    return 0U; /* nothing was fetched to package */
  }
  const bool incomplete = priv_mdl_fetch_run_incomplete(stats);
  if (incomplete) {
    if (!allow_incomplete) {
      ra8_err_t output_error = priv_mdl_stream_text(k_ra8_ok,
                                                    diagnostic,
                                                    "  combine: NOT packaged -- run is "
                                                    "incomplete (");
      output_error = priv_mdl_stream_u64(output_error, diagnostic, stats->chapters_failed);
      output_error = priv_mdl_stream_text(output_error, diagnostic, " chapter(s) / ");
      output_error = priv_mdl_stream_u64(output_error, diagnostic, stats->pages_failed);
      output_error = priv_mdl_stream_text(output_error,
                                          diagnostic,
                                          " page(s) failed); pass --allow-incomplete to force "
                                          "a marked archive\n");
      return (output_error == k_ra8_ok) ? 0U : 1U;
    }
  }
  return internal_pack_combined_dir(storage,
                                    format,
                                    series_dir,
                                    combined_rel,
                                    incomplete,
                                    meta,
                                    ws,
                                    output,
                                    diagnostic);
}
 
size_t mdl_pack_combined(mdl_storage_t*           storage,
                         mdl_format_t             format,
                         bool                     allow_incomplete,
                         const char*              series_dir,
                         const char*              combined_rel,
                         const mdl_fetch_stats_t* stats,
                         mdl_export_workspace_t*  ws,
                         ra8_io_stream_t*         output,
                         ra8_io_stream_t*         diagnostic)
{
  return mdl_pack_combined_meta(storage,
                                format,
                                allow_incomplete,
                                series_dir,
                                combined_rel,
                                stats,
                                nullptr,
                                ws,
                                output,
                                diagnostic);
}