wa_fetch.h

Go to the documentation of this file.

 
#ifndef RCBENCH_WA_FETCH_H
#define RCBENCH_WA_FETCH_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "fw_image.h"
#include "fw_release.h"
#include "fw_upload.h"
#include "wa_session.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define WA_FETCH_CHECK_MS     30000u
#define WA_FETCH_JOIN_MS      30000u
#define WA_FETCH_DOWNLOAD_MS  180000u
#define WA_FETCH_OP_MS        10000u
 
typedef enum {
    WA_JOB_CHECK = 0,
    WA_JOB_DOWNLOAD,
} wa_job_t;

typedef enum {
    WA_CH_STABLE = 0,  
    WA_CH_TESTING,     
} wa_channel_t;
 
typedef enum {
    WA_PH_IDLE = 0,    
    WA_PH_JOINING,     
    WA_PH_ASKING,      
    WA_PH_SUMS,        
    WA_PH_IMAGE,       
    WA_PH_CHECKING,    
    WA_PH_ENDED,       
} wa_phase_t;

typedef enum {
    WA_GOT_NONE = 0,   
    WA_GOT_NEWER,      
    WA_GOT_CURRENT,    
    WA_GOT_STAGED,     
    WA_GOT_NO_NET,     
    WA_GOT_BLOCKED,    
    WA_GOT_ABORTED,    
    WA_GOT_JOIN,       
    WA_GOT_RADIO,      
    WA_GOT_TIMEOUT,    
    WA_GOT_CONNECT,    
    WA_GOT_REFUSED,    
    WA_GOT_UNEXPECTED, 
    WA_GOT_SUMS,       
    WA_GOT_HASH,       
    WA_GOT_IMAGE,      
    WA_GOT_MEMORY,     
    WA_GOT_LIMIT,      
    WA_GOT_UNVERSIONED,
    WA_GOT_PAST_LINE,  
} wa_got_t;

typedef enum {
    WA_WHY_NONE = 0,
    WA_WHY_ARMED,      
    WA_WHY_SUPPLY,     
    WA_WHY_RUN,        
    WA_WHY_STOP,
    WA_WHY_FILES,      
    WA_WHY_COPROC,     
    WA_WHY_INSTALL,    
    WA_WHY_CANCEL,     
    WA_WHY_BUSY,       
    WA_WHY_DRAWING,    
} wa_why_t;
 
typedef struct {
    wa_job_t      job;
    wa_channel_t  channel;  
    wa_phase_t    phase;
    wa_got_t      got;
    wa_why_t      why;      
    wa_join_err_t join;     
    fw_rel_err_t  rel;      
    fw_err_t      img;      
    int           status;   
    uint32_t      gen;      
    uint32_t      start_ms;
    fw_version_t  running;
    fw_version_t  found;    
    uint32_t      done;     
    uint32_t      total;    
    uint32_t      budget_ms;
    bool          owe_off;  
    bool          owe_run;  
} wa_fetch_t;

void wa_fetch_init(wa_fetch_t *f, fw_version_t running);

wa_why_t wa_fetch_gate(bool armed, bool supply, bool run, bool coproc,
                       bool installing);

wa_why_t wa_fetch_start_gate(wa_why_t gate, bool taken, bool task_alive,
                             bool other);

wa_got_t wa_fetch_start(wa_fetch_t *f, wa_job_t job, fw_version_t want,
                        wa_channel_t ch, bool have_net, wa_why_t gate,
                        uint32_t now_ms);

bool wa_fetch_offers(const wa_fetch_t *f, wa_channel_t now);

bool wa_fetch_stale(const wa_fetch_t *f, wa_channel_t now);

bool wa_fetch_busy(const wa_fetch_t *f);

bool wa_fetch_has_found(const wa_fetch_t *f);

void wa_fetch_tick(wa_fetch_t *f, uint32_t now_ms, wa_why_t abort,
                   const wa_t *w);

void wa_fetch_abort(wa_fetch_t *f, wa_why_t why);

uint32_t wa_fetch_left(const wa_fetch_t *f, uint32_t now_ms);

bool wa_fetch_take_off(wa_fetch_t *f);
bool wa_fetch_take_run(wa_fetch_t *f);

typedef struct {
    wa_got_t     got;
    wa_why_t     why;
    fw_rel_err_t rel;
    fw_err_t     img;
    int          status;
    fw_version_t found;
} wa_fetch_res_t;
 
/* What the runner reports, each for job @p gen; a report for another job,
 * or for one that has ended, is dropped. */
void wa_fetch_on_phase(wa_fetch_t *f, uint32_t gen, wa_phase_t ph);
void wa_fetch_on_bytes(wa_fetch_t *f, uint32_t gen, uint32_t done,
                       uint32_t total);
void wa_fetch_on_end(wa_fetch_t *f, uint32_t gen, const wa_fetch_res_t *r);
 
/* ---------------------------------------------------------- the runner */

typedef struct {
    int     status;     
    int64_t length;     
    bool    chunked;    
    size_t  loc_n;      
    bool    loc_cut;    
} wa_http_head_t;

typedef struct {
    bool    (*open)(void *ctx, const char *url, uint32_t timeout_ms,
                    bool api, wa_http_head_t *head, char *loc,
                    size_t loc_cap);
    int32_t (*read)(void *ctx, uint8_t *dst, uint32_t n,
                    uint32_t timeout_ms);
    void    (*close)(void *ctx);
    void    *ctx;
} wa_http_t;
 
typedef struct {
    const wa_http_t *http;
    uint32_t (*now)(void *ctx);
    bool     (*stopped)(void *ctx);
    void     (*report)(void *ctx, wa_phase_t ph, uint32_t done,
                       uint32_t total);
    uint8_t *(*alloc)(void *ctx, uint32_t bytes);
    void     *ctx;
 
    uint32_t  start_ms;      
    uint32_t  budget_ms;     
    uint32_t  slot;          
    fw_version_t running;
    bool      running_ok;    
    wa_channel_t channel;    
 
    /* Scratch the platform owns, in PSRAM on the panel. */
    char     *url;           
    char     *loc;           
    uint8_t  *io;            
    uint32_t  io_cap;
    char     *sums;          
    fw_upload_t *up;         
} wa_run_t;

void wa_run_check(const wa_run_t *r, wa_fetch_res_t *out);

void wa_run_download(const wa_run_t *r, fw_version_t v, wa_fetch_res_t *out);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_WA_FETCH_H */