delivery.h

Go to the documentation of this file.

 
#ifndef STASIS_DELIVERY_H
#define STASIS_DELIVERY_H
 
#include <string.h>
#include <stdbool.h>
#include "artifactory.h"
#include "docker.h"
#include "environment.h"
#include "ini.h"
#include "multiprocessing.h"
 
#define DELIVERY_PLATFORM_MAX 4
#define DELIVERY_PLATFORM_MAXLEN 65
#define DELIVERY_PLATFORM 0
#define DELIVERY_PLATFORM_CONDA_SUBDIR 1
#define DELIVERY_PLATFORM_CONDA_INSTALLER 2
#define DELIVERY_PLATFORM_RELEASE 3
 
#define DELIVERY_REWRITE_SPEC_STAGE_1 0
#define DELIVERY_REWRITE_SPEC_STAGE_2 1
 
#define INSTALL_PKG_CONDA 1 << 1            
#define INSTALL_PKG_CONDA_DEFERRED 1 << 2   
#define INSTALL_PKG_PIP 1 << 3              
#define INSTALL_PKG_PIP_DEFERRED 1 << 4     
 
#define DEFER_CONDA 0                       
#define DEFER_PIP 1                         
 
struct Content {
    unsigned type;
    char *filename;
    char *data;
};

#define TEST_NUM_ALLOC_INITIAL 10

struct Test {
    char *name;                     
    char *version;                  
    char *repository;               
    char *script_setup;             
    char *script;                   
    bool disable;                   
    bool parallel;                  
    char *build_recipe;             
    char *repository_info_ref;      
    char *repository_info_tag;      
    struct StrList *repository_remove_tags;   
    struct Runtime *runtime;         
    int timeout;                    
}; 

struct Delivery {
    struct STASIS_INI_FP {
        struct INIFILE *delivery;
        struct INIFILE *cfg;
        struct INIFILE *mission;
        char *delivery_path;
        char *cfg_path;
        char *mission_path;
    } _stasis_ini_fp;

    struct System {
        char *arch;                     
        char **platform;                
    } system;

    struct Storage {
        char *root;                     
        char *tmpdir;                   
        char *output_dir;               
        char *delivery_dir;             
        char *cfgdump_dir;              
        char *tools_dir;                
        char *mission_dir;              
        char *package_dir;              
        char *results_dir;              
        char *meta_dir;                 
        char *conda_install_prefix;     
        char *conda_artifact_dir;       
        char *conda_staging_dir;        
        char *conda_staging_url;        
        char *docker_artifact_dir;      
        char *wheel_artifact_dir;       
        char *wheel_staging_dir;        
        char *wheel_staging_url;        
        char *build_dir;                
        char *build_recipes_dir;        
        char *build_sources_dir;        
        char *build_testing_dir;        
        char *build_docker_dir;         
    } storage;

    struct Meta {
        char *name;                
        char *version;             
        int rc;                    
        char *python;              
        char *python_compact;      
        char *based_on;            
        char *mission;             
        char *codename;            
        bool final;                
    } meta;

    struct Info {
        char *release_name;            
        char *build_name;
        char *build_number;
        struct tm *time_info;          
        time_t time_now;               
        char *time_str_epoch;          
    } info;

    struct Conda {
        char *installer_baseurl;                
        char *installer_name;                   
        char *installer_version;                
        char *installer_platform;               
        char *installer_arch;                   
        char *installer_path;                   
        char *tool_version;                     
        char *tool_build_version;               
        struct StrList *conda_packages;         
        struct StrList *conda_packages_defer;   
        struct StrList *conda_packages_purge;   
        struct StrList *pip_packages;           
        struct StrList *pip_packages_defer;     
        struct StrList *pip_packages_purge;     
        struct StrList *wheels_packages;        
    } conda;

    struct Runtime {
        RuntimeEnv *environ;        
    } runtime;
 
    struct Tests {
        struct Test **test;
        size_t num_used;
        size_t num_alloc;
    } *tests;
 
    struct Deploy {
        struct JFRT_Auth jfrog_auth;
 
        struct JFrog {
            struct StrList *files;
            struct JFRT_Upload upload_ctx;
            char *repo;
            char *dest;
        } jfrog[1000];
 
        struct Docker {
            struct DockerCapabilities capabilities;
            char *image_compression;
            char *dockerfile;
            char *registry;
            char *test_script;
            struct StrList *build_args;
            struct StrList *tags;
        } docker;
    } deploy;
 
    struct Rule {
        struct INIFILE *_handle;
        bool enable_final;          
        char *release_fmt;          
        char *build_name_fmt;       
        char *build_number_fmt;     
        struct Content content[1000];
    } rules;
};

int delivery_init(struct Delivery *ctx, int render_mode);

void delivery_free(struct Delivery *ctx);

void delivery_meta_show(struct Delivery *ctx);

void delivery_conda_show(struct Delivery *ctx);

void delivery_tests_show(struct Delivery *ctx);

void delivery_runtime_show(struct Delivery *ctx);

int delivery_build_recipes(struct Delivery *ctx);

struct StrList *delivery_build_wheels(struct Delivery *ctx);

int delivery_index_wheel_artifacts(struct Delivery *ctx);

char *delivery_get_release_header(struct Delivery *ctx);

void delivery_rewrite_spec(struct Delivery *ctx, char *filename, unsigned stage);

int delivery_copy_wheel_artifacts(struct Delivery *ctx);

int delivery_copy_conda_artifacts(struct Delivery *ctx);

int delivery_get_conda_installer(struct Delivery *ctx, char *installer_url);

void delivery_get_conda_installer_url(struct Delivery *ctx, char *result, size_t maxlen);

int delivery_install_packages(struct Delivery *ctx, char *conda_install_dir, char *env_name, int type, struct StrList *manifest[]);

int delivery_index_conda_artifacts(struct Delivery *ctx);

void delivery_tests_run(struct Delivery *ctx);

void delivery_defer_packages(struct Delivery *ctx, int type);

void delivery_conda_enable(struct Delivery *ctx, char *conda_install_dir);

void delivery_install_conda(char *install_script, char *conda_install_dir);

int delivery_format_str(struct Delivery *ctx, char **dest, size_t maxlen, const char *fmt);
 
// helper function
int delivery_gather_tool_versions(struct Delivery *ctx);
 
// helper function
int delivery_init_tmpdir(struct Delivery *ctx);
 
void delivery_init_dirs_stage1(struct Delivery *ctx);
 
void delivery_init_dirs_stage2(struct Delivery *ctx);
 
int delivery_init_platform(struct Delivery *ctx);
 
int delivery_init_artifactory(struct Delivery *ctx);
 
int delivery_artifact_upload(struct Delivery *ctx);
 
int delivery_mission_render_files(struct Delivery *ctx);
 
int delivery_docker(struct Delivery *ctx);
 
int delivery_fixup_test_results(struct Delivery *ctx);
 
int bootstrap_build_info(struct Delivery *ctx);
 
int delivery_dump_metadata(struct Delivery *ctx);
 
int populate_info(struct Delivery *ctx);
 
int populate_delivery_cfg(struct Delivery *ctx, int render_mode);
 
int populate_delivery_ini(struct Delivery *ctx, int render_mode);
 
int populate_mission_ini(struct Delivery **ctx, int render_mode);
 
void validate_delivery_ini(struct INIFILE *ini);
 
int filter_repo_tags(char *repo, struct StrList *patterns);
 
#define DELIVERY_NOT_FOUND 0
#define DELIVERY_FOUND 1
int delivery_exists(struct Delivery *ctx);
 
int delivery_overlay_packages_from_env(struct Delivery *ctx, const char *env_name);

int delivery_conda_enforce_package_version(struct Delivery *ctx, const char *env_name, const char *name);

int delivery_series_sync(struct Delivery *ctx);

int delivery_purge_packages(struct Delivery *ctx, const char *env_name, int use_pkg_manager);

void delivery_export(const struct Delivery *ctx, char *envs[]);

void delivery_rewrite_stage1(struct Delivery *ctx, char *specfile);

void delivery_rewrite_stage2(struct Delivery *ctx, char *specfile);

struct Delivery *delivery_duplicate(struct Delivery *ctx);

struct Tests *tests_init(size_t num_tests);

int tests_add(struct Tests *tests, struct Test *x);

void test_free(struct Test **x);

void tests_free(struct Tests **x);

struct Test *test_init();
 
 
#endif //STASIS_DELIVERY_H