mdl_report.c

Go to the documentation of this file.

#include "mdl_report.h"
 
#include <stdint.h>
#include <stdio.h>
 
#include "mdl_fetch.h"
#include "mdl_fetch_internal.h"
#include "mdl_stream_internal.h"
#include "ra8_attributes.h"

typedef enum : uint32_t {
  k_bytes_per_kib      = 1024U,         
  k_bytes_per_mib      = 1024U * 1024U, 
  k_ms_per_sec         = 1000U,         
  k_human_bytes        = 32U,           
  k_progress_bar_width = 20U,           
  k_percent_scale      = 100U,          
  k_percent_two_digits = 10U,           
} mdl_report_scale_t;

RA8_INTERNAL static void internal_fmt_size(uint64_t bytes, char* buf, size_t cap)
{
  const double b = (double)bytes;
  if (bytes >= (uint64_t)k_bytes_per_mib) {
    (void)snprintf(buf, cap, "%.1f MB", b / (double)k_bytes_per_mib);
    return;
  }
  if (bytes >= (uint64_t)k_bytes_per_kib) {
    (void)snprintf(buf, cap, "%.1f KB", b / (double)k_bytes_per_kib);
    return;
  }
  (void)snprintf(buf, cap, "%llu B", (unsigned long long)bytes);
}

RA8_INTERNAL static void
internal_fmt_rate(uint64_t bytes, uint32_t elapsed_ms, char* buf, size_t cap)
{
  if (elapsed_ms == 0U) {
    (void)snprintf(buf, cap, "-- KB/s");
    return;
  }
  const double bps = ((double)bytes * (double)k_ms_per_sec) / (double)elapsed_ms;
  if (bps >= (double)k_bytes_per_mib) {
    (void)snprintf(buf, cap, "%.1f MB/s", bps / (double)k_bytes_per_mib);
    return;
  }
  (void)snprintf(buf, cap, "%.1f KB/s", bps / (double)k_bytes_per_kib);
}

RA8_INTERNAL static ra8_err_t
internal_report_position(ra8_err_t error, ra8_io_stream_t* output, const mdl_fetch_progress_t* ev)
{
  error = priv_mdl_stream_text(error, output, "[ch ");
  error = priv_mdl_stream_u64(error, output, ev->chapter_index);
  error = priv_mdl_stream_text(error, output, "/");
  error = priv_mdl_stream_u64(error, output, ev->chapter_total);
  error = priv_mdl_stream_text(error, output, " ");
  error = priv_mdl_stream_text(error, output, ev->chapter_id);
  error = priv_mdl_stream_text(error, output, "] page ");
  error = priv_mdl_stream_u64(error, output, ev->page_index);
  error = priv_mdl_stream_text(error, output, "/");
  return priv_mdl_stream_u64(error, output, ev->page_total);
}
 
ra8_err_t mdl_report_progress(void* ctx, const mdl_fetch_progress_t* ev)
{
  if (ev == nullptr) {
    return k_ra8_ok;
  }
  ra8_io_stream_t* output = (ra8_io_stream_t*)ctx;
  ra8_err_t        error  = priv_mdl_stream_text(k_ra8_ok, output, "  ");
  error                   = internal_report_position(error, output, ev);
  if (ev->reused) {
    return priv_mdl_stream_text(error, output, "  reused\n");
  }
  char size[k_human_bytes];
  char rate[k_human_bytes];
  internal_fmt_size(ev->page_bytes, size, sizeof(size));
  internal_fmt_rate(ev->page_bytes, ev->elapsed_ms, rate, sizeof(rate));
  error = priv_mdl_stream_text(error, output, "  ");
  error = priv_mdl_stream_text(error, output, size);
  error = priv_mdl_stream_text(error, output, " @ ");
  error = priv_mdl_stream_text(error, output, rate);
  return priv_mdl_stream_text(error, output, "\n");
}

RA8_INTERNAL static uint32_t internal_percent_pad_width(uint32_t pct)
{
  if (pct < k_percent_two_digits) {
    return 2U;
  }
  if (pct < k_percent_scale) {
    return 1U;
  }
  return 0U;
}
 
ra8_err_t mdl_report_progress_bar(void* ctx, const mdl_fetch_progress_t* ev)
{
  if (ev == nullptr) {
    return k_ra8_ok;
  }
  ra8_io_stream_t* output    = (ra8_io_stream_t*)ctx;
  const size_t     bar_width = (size_t)k_progress_bar_width;
  size_t           filled    = 0U;
  if (ev->page_total > 0U) {
    filled = (ev->page_index * bar_width) / ev->page_total;
    if (filled > bar_width) {
      filled = bar_width;
    }
  }
  const uint32_t pct = (ev->page_total > 0U)
                         ? (uint32_t)((ev->page_index * (size_t)k_percent_scale) / ev->page_total)
                         : 0U;
 
  ra8_err_t error = priv_mdl_stream_text(k_ra8_ok, output, "\r  [");
  error           = priv_mdl_stream_repeat(error, output, '=', filled);
  error           = priv_mdl_stream_repeat(error, output, ' ', bar_width - filled);
  error           = priv_mdl_stream_text(error, output, "] ");
  error           = priv_mdl_stream_repeat(error, output, ' ', internal_percent_pad_width(pct));
  error           = priv_mdl_stream_u64(error, output, pct);
  error           = priv_mdl_stream_text(error, output, "% ");
  error           = internal_report_position(error, output, ev);
  if (ev->reused) {
    error = priv_mdl_stream_text(error, output, " (reused)");
  } else {
    char size[k_human_bytes];
    char rate[k_human_bytes];
    internal_fmt_size(ev->page_bytes, size, sizeof(size));
    internal_fmt_rate(ev->page_bytes, ev->elapsed_ms, rate, sizeof(rate));
    error = priv_mdl_stream_text(error, output, " (");
    error = priv_mdl_stream_text(error, output, size);
    error = priv_mdl_stream_text(error, output, " @ ");
    error = priv_mdl_stream_text(error, output, rate);
    error = priv_mdl_stream_text(error, output, ")");
  }
  if (ev->page_index >= ev->page_total) {
    error = priv_mdl_stream_text(error, output, "\n");
  }
  return priv_mdl_stream_flush(error, output);
}
 
ra8_err_t mdl_report_failures(ra8_io_stream_t* diagnostic, const mdl_fetch_faillog_t* log)
{
  if (log->total == 0U) {
    return k_ra8_ok;
  }
  ra8_err_t error = priv_mdl_stream_u64(k_ra8_ok, diagnostic, log->total);
  error           = priv_mdl_stream_text(error, diagnostic, " failure(s) this run:\n");
  for (size_t i = 0U; i < log->count; ++i) {
    char reason[k_mdl_reason_max];
    priv_mdl_fetch_reason(log->items[i].err, log->items[i].status, reason, sizeof(reason));
    error = priv_mdl_stream_text(error, diagnostic, "  FAILED ");
    error = priv_mdl_stream_text(error, diagnostic, log->items[i].url);
    error = priv_mdl_stream_text(error, diagnostic, " -- ");
    error = priv_mdl_stream_text(error, diagnostic, reason);
    error = priv_mdl_stream_text(error, diagnostic, "\n");
  }
  if (log->total > log->count) {
    error = priv_mdl_stream_text(error, diagnostic, "  ... and ");
    error = priv_mdl_stream_u64(error, diagnostic, log->total - log->count);
    error = priv_mdl_stream_text(error, diagnostic, " more (log truncated)\n");
  }
  return error;
}