git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/bdb.h

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2015 Kern Sibbald
   5    Copyright (C) 2000-2015 Free Software Foundation Europe e.V.
   6
   7    The original author of Bacula is Kern Sibbald, with contributions
   8    from many others, a complete list can be found in the file AUTHORS.
   9
  10    You may use this file and others of this release according to the
  11    license defined in the LICENSE file, which includes the Affero General
  12    Public License, v3.0 ("AGPLv3") and some additional permissions and
  13    terms pursuant to its AGPLv3 Section 7.
  14
  15    This notice must be preserved when any source code is
  16    conveyed and/or propagated.
  17
  18    Bacula(R) is a registered trademark of Kern Sibbald.
  19 */
  20 /*
  21  *  Catalog DB Interface class
  22  *
  23  *  Written by Kern E. Sibbald
  24  *
  25  */
  26
  27 #ifndef __BDB_H_
  28 #define __BDB_H_ 1
  29
  30 class BDB: public SMARTALLOC {
  31 public:
  32    dlink m_link;                      /* queue control */
  33    brwlock_t m_lock;                  /* transaction lock */
  34    SQL_DRIVER m_db_driver_type;       /* driver type */
  35    SQL_DBTYPE m_db_type;              /* database type */
  36    char *m_db_name;                   /* database name */
  37    char *m_db_user;                   /* database user */
  38    char *m_db_address;                /* host name address */
  39    char *m_db_socket;                 /* socket for local access */
  40    char *m_db_password;               /* database password */
  41    char *m_db_driver;                 /* database driver */
  42    char *m_db_driverdir;              /* database driver dir */
  43    int m_ref_count;                   /* reference count */
  44    int m_db_port;                     /* port for host name address */
  45    char *m_db_ssl_key;                /* path name to the key file */
  46    char *m_db_ssl_cert;               /* path name to the certificate file */
  47    char *m_db_ssl_ca;                 /* path name to the certificate authority file */
  48    char *m_db_ssl_capath;             /* path name to a directory that contains trusted SSL CA certificates in PEM format */
  49    char *m_db_ssl_cipher;             /* a list of permissible ciphers to use for SSL encryption */
  50    bool m_disabled_batch_insert;      /* explicitly disabled batch insert mode ? */
  51    bool m_dedicated;                  /* is this connection dedicated? */
  52    bool m_use_fatal_jmsg;             /* use Jmsg(M_FATAL) after bad queries? */
  53    bool m_connected;                  /* connection made to db */
  54    bool m_have_batch_insert;          /* have batch insert support ? */
  55
  56    /* Cats Internal */
  57    int m_status;                      /* status */
  58    int m_num_rows;                    /* number of rows returned by last query */
  59    int m_num_fields;                  /* number of fields returned by last query */
  60    int m_rows_size;                   /* size of malloced rows */
  61    int m_fields_size;                 /* size of malloced fields */
  62    int m_row_number;                  /* row number from xx_data_seek */
  63    int m_field_number;                /* field number from sql_field_seek */
  64    SQL_ROW m_rows;                    /* defined rows */
  65    SQL_FIELD *m_fields;               /* defined fields */
  66    bool m_allow_transactions;         /* transactions allowed */
  67    bool m_transaction;                /* transaction started */
  68
  69    POOLMEM *cached_path;              /* cached path name */
  70    POOLMEM *cmd;                      /* SQL command string */
  71    POOLMEM *errmsg;                   /* nicely edited error message */
  72    POOLMEM *esc_name;                 /* Escaped file name */
  73    POOLMEM *esc_obj;                  /* Escaped restore object */
  74    POOLMEM *esc_path;                 /* Escaped path name */
  75    POOLMEM *fname;                    /* Filename only */
  76    POOLMEM *path;                     /* Path only */
  77    uint32_t cached_path_id;           /* cached path id */
  78    int cached_path_len;               /* length of cached path */
  79    int changes;                       /* changes during transaction */
  80    int fnl;                           /* file name length */
  81    int pnl;                           /* path name length */
  82
  83    /* methods */
  84    BDB() {};
  85    virtual ~BDB() {};
  86    const char *get_db_name(void) { return m_db_name; };
  87    const char *get_db_user(void) { return m_db_user; };
  88    const bool is_connected(void) { return m_connected; };
  89    const bool is_dedicated(void) { return m_dedicated; };
  90    bool use_fatal_jmsg(void) { return m_use_fatal_jmsg; };
  91    const bool batch_insert_available(void) { return m_have_batch_insert; };
  92    void set_use_fatal_jmsg(bool val) { m_use_fatal_jmsg = val; };
  93    void increment_refcount(void) { m_ref_count++; };
  94    const int bdb_get_type_index(void) { return m_db_type; };
  95    const char *bdb_get_engine_name(void);
  96
  97    BDB *bdb_clone_database_connection(JCR *jcr, bool mult_db_connections);
  98    bool bdb_match_database(const char *db_driver, const char *db_name,
  99             const char *bdb_address, int db_port);
 100    bool bdb_sql_query(const char *query, int flags=0);
 101    void bdb_lock(const char *file=__FILE__, int line=__LINE__);
 102    void bdb_unlock(const char *file=__FILE__, int line=__LINE__);
 103    void print_lock_info(FILE *fp);
 104
 105    /* sql.c */
 106    bool UpdateDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 107    bool InsertDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 108    bool QueryDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 109    int  DeleteDB(JCR *jcr, char *cmd, const char *file=__FILE__, int line=__LINE__);
 110    char *bdb_strerror() { return errmsg; };
 111    bool bdb_check_version(JCR *jcr);
 112    bool bdb_open_batch_connexion(JCR *jcr);
 113    bool bdb_check_max_connections(JCR *jcr, uint32_t max_concurrent_jobs);
 114
 115    /* sql_delete.c */
 116    int bdb_delete_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
 117    int bdb_delete_media_record(JCR *jcr, MEDIA_DBR *mr);
 118    int bdb_purge_media_record(JCR *jcr, MEDIA_DBR *mr);
 119    int bdb_delete_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
 120
 121    /* sql_find.c */
 122    bool bdb_find_last_job_end_time(JCR *jcr, JOB_DBR *jr, POOLMEM **etime, char *job);
 123    bool bdb_find_last_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job, int JobLevel);
 124    bool bdb_find_job_start_time(JCR *jcr, JOB_DBR *jr, POOLMEM **stime, char *job);
 125    bool bdb_find_last_jobid(JCR *jcr, const char *Name, JOB_DBR *jr);
 126    int bdb_find_next_volume(JCR *jcr, int index, bool InChanger, MEDIA_DBR *mr);
 127    bool bdb_find_failed_job_since(JCR *jcr, JOB_DBR *jr, POOLMEM *stime, int &JobLevel);
 128
 129    /* sql_create.c */
 130    int bdb_create_path_record(JCR *jcr, ATTR_DBR *ar);
 131    bool bdb_create_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 132    bool bdb_create_job_record(JCR *jcr, JOB_DBR *jr);
 133    int bdb_create_media_record(JCR *jcr, MEDIA_DBR *media_dbr);
 134    int bdb_create_client_record(JCR *jcr, CLIENT_DBR *cr);
 135    bool bdb_create_fileset_record(JCR *jcr, FILESET_DBR *fsr);
 136    bool bdb_create_pool_record(JCR *jcr, POOL_DBR *pool_dbr);
 137    bool bdb_create_jobmedia_record(JCR *jcr, JOBMEDIA_DBR *jr);
 138    int bdb_create_counter_record(JCR *jcr, COUNTER_DBR *cr);
 139    bool bdb_create_device_record(JCR *jcr, DEVICE_DBR *dr);
 140    bool bdb_create_storage_record(JCR *jcr, STORAGE_DBR *sr);
 141    bool bdb_create_mediatype_record(JCR *jcr, MEDIATYPE_DBR *mr);
 142    bool bdb_create_attributes_record(JCR *jcr, ATTR_DBR *ar);
 143    bool bdb_create_restore_object_record(JCR *jcr, ROBJECT_DBR *ar);
 144    bool bdb_create_base_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 145    bool bdb_commit_base_file_attributes_record(JCR *jcr);
 146    bool bdb_create_base_file_list(JCR *jcr, char *jobids);
 147    bool bdb_create_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
 148    int bdb_create_file_record(JCR *jcr, ATTR_DBR *ar);
 149    int bdb_create_filename_record(JCR *jcr, ATTR_DBR *ar);
 150    bool bdb_create_batch_file_attributes_record(JCR *jcr, ATTR_DBR *ar);
 151
 152    /* sql_get.c */
 153    bool bdb_get_file_record(JCR *jcr, JOB_DBR *jr, FILE_DBR *fdbr);
 154    bool bdb_get_snapshot_record(JCR *jcr, SNAPSHOT_DBR *snap);
 155    bool bdb_get_volume_jobids(JCR *jcr,
 156             MEDIA_DBR *mr, db_list_ctx *lst);
 157    bool bdb_get_base_file_list(JCR *jcr, bool use_md5,
 158             DB_RESULT_HANDLER *result_handler,void *ctx);
 159    int bdb_get_filename_record(JCR *jcr);
 160    int bdb_get_path_record(JCR *jcr);
 161    bool bdb_get_pool_record(JCR *jcr, POOL_DBR *pdbr);
 162    bool bdb_get_pool_numvols(JCR *jcr, POOL_DBR *pdbr);
 163    int bdb_get_client_record(JCR *jcr, CLIENT_DBR *cr);
 164    bool bdb_get_job_record(JCR *jcr, JOB_DBR *jr);
 165    int bdb_get_job_volume_names(JCR *jcr, JobId_t JobId, POOLMEM **VolumeNames);
 166    bool bdb_get_file_attributes_record(JCR *jcr, char *fname, JOB_DBR *jr, FILE_DBR *fdbr);
 167    int bdb_get_fileset_record(JCR *jcr, FILESET_DBR *fsr);
 168    bool bdb_get_media_record(JCR *jcr, MEDIA_DBR *mr);
 169    int bdb_get_num_media_records(JCR *jcr);
 170    int bdb_get_num_pool_records(JCR *jcr);
 171    int bdb_get_pool_ids(JCR *jcr, int *num_ids, DBId_t **ids);
 172    int bdb_get_client_ids(JCR *jcr, int *num_ids, DBId_t **ids);
 173    bool bdb_get_media_ids(JCR *jcr, MEDIA_DBR *mr, int *num_ids, uint32_t **ids);
 174    int  bdb_get_job_volume_parameters(JCR *jcr, JobId_t JobId, VOL_PARAMS **VolParams);
 175    bool bdb_get_counter_record(JCR *jcr, COUNTER_DBR *cr);
 176    bool bdb_get_query_dbids(JCR *jcr, POOL_MEM &query, dbid_list &ids);
 177    bool bdb_get_file_list(JCR *jcr, char *jobids,
 178             bool use_md5, bool use_delta,
 179             DB_RESULT_HANDLER *result_handler, void *ctx);
 180    bool bdb_get_base_jobid(JCR *jcr, JOB_DBR *jr, JobId_t *jobid);
 181    bool bdb_get_accurate_jobids(JCR *jcr, JOB_DBR *jr, db_list_ctx *jobids);
 182    bool bdb_get_used_base_jobids(JCR *jcr, POOLMEM *jobids, db_list_ctx *result);
 183    bool bdb_get_restoreobject_record(JCR *jcr, ROBJECT_DBR *rr);
 184
 185 /* sql_list.c */
 186    void bdb_list_pool_records(JCR *jcr, POOL_DBR *pr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
 187    alist *bdb_list_job_records(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx, e_list_type type);
 188    void bdb_list_job_totals(JCR *jcr, JOB_DBR *jr, DB_LIST_HANDLER sendit, void *ctx);
 189    void bdb_list_files_for_job(JCR *jcr, uint32_t jobid, DB_LIST_HANDLER sendit, void *ctx);
 190    void bdb_list_media_records(JCR *jcr, MEDIA_DBR *mdbr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 191    void bdb_list_jobmedia_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 192    void bdb_list_joblog_records(JCR *jcr, JobId_t JobId, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 193    int  bdb_list_sql_query(JCR *jcr, const char *query, DB_LIST_HANDLER *sendit, void *ctx, int verbose, e_list_type type);
 194    void bdb_list_client_records(JCR *jcr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 195    void bdb_list_copies_records(JCR *jcr, uint32_t limit, char *jobids, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 196    void bdb_list_base_files_for_job(JCR *jcr, JobId_t jobid, DB_LIST_HANDLER *sendit, void *ctx);
 197    void bdb_list_restore_objects(JCR *jcr, ROBJECT_DBR *rr, DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 198    void bdb_list_snapshot_records(JCR *jcr, SNAPSHOT_DBR *sdbr,
 199               DB_LIST_HANDLER *sendit, void *ctx, e_list_type type);
 200
 201
 202    /* sql_update.c */
 203    bool bdb_update_job_start_record(JCR *jcr, JOB_DBR *jr);
 204    int  bdb_update_job_end_record(JCR *jcr, JOB_DBR *jr);
 205    int  bdb_update_client_record(JCR *jcr, CLIENT_DBR *cr);
 206    int  bdb_update_pool_record(JCR *jcr, POOL_DBR *pr);
 207    bool bdb_update_storage_record(JCR *jcr, STORAGE_DBR *sr);
 208    int  bdb_update_media_record(JCR *jcr, MEDIA_DBR *mr);
 209    int  bdb_update_media_defaults(JCR *jcr, MEDIA_DBR *mr);
 210    int  bdb_update_counter_record(JCR *jcr, COUNTER_DBR *cr);
 211    int  bdb_add_digest_to_file_record(JCR *jcr, FileId_t FileId, char *digest, int type);
 212    int  bdb_mark_file_record(JCR *jcr, FileId_t FileId, JobId_t JobId);
 213    void bdb_make_inchanger_unique(JCR *jcr, MEDIA_DBR *mr);
 214    int  bdb_update_stats(JCR *jcr, utime_t age);
 215    bool bdb_update_snapshot_record(JCR *jcr, SNAPSHOT_DBR *sr);
 216
 217    /* Pure virtual low level methods */
 218    virtual void bdb_escape_string(JCR *jcr, char *snew, char *old, int len) = 0;
 219    virtual char *bdb_escape_object(JCR *jcr, char *old, int len) = 0;
 220    virtual void bdb_unescape_object(JCR *jcr, char *from, int32_t expected_len,
 221                    POOLMEM **dest, int32_t *len) = 0;
 222    virtual bool bdb_open_database(JCR *jcr) = 0;
 223    virtual void bdb_close_database(JCR *jcr) = 0;
 224    virtual void bdb_start_transaction(JCR *jcr) = 0;
 225    virtual void bdb_end_transaction(JCR *jcr) = 0;
 226    virtual bool bdb_sql_query(const char *query, DB_RESULT_HANDLER *result_handler, void *ctx) = 0;
 227    virtual void bdb_thread_cleanup(void) = 0;
 228
 229    /* By default, we use bdb_sql_query */
 230    virtual bool bdb_big_sql_query(const char *query,
 231                    DB_RESULT_HANDLER *result_handler, void *ctx) {
 232       return bdb_sql_query(query, result_handler, ctx);
 233    };
 234
 235    /* Cats Internal */
 236 #ifdef CATS_PRIVATE_DBI
 237    int sql_num_rows(void) { return m_num_rows; };
 238    void sql_field_seek(int field) { m_field_number = field; };
 239    int sql_num_fields(void) { return m_num_fields; };
 240    virtual void sql_free_result(void) = 0;
 241    virtual SQL_ROW sql_fetch_row(void) = 0;
 242    virtual bool sql_query(const char *query, int flags=0) = 0;
 243    virtual const char *sql_strerror(void) = 0;
 244    virtual void sql_data_seek(int row) = 0;
 245    virtual int sql_affected_rows(void) = 0;
 246    virtual uint64_t sql_insert_autokey_record(const char *query, const char *table_name) = 0;
 247    virtual SQL_FIELD *sql_fetch_field(void) = 0;
 248    virtual bool sql_field_is_not_null(int field_type) = 0;
 249    virtual bool sql_field_is_numeric(int field_type) = 0;
 250    virtual bool sql_batch_start(JCR *jcr) = 0;
 251    virtual bool sql_batch_end(JCR *jcr, const char *error) = 0;
 252    virtual bool sql_batch_insert(JCR *jcr, ATTR_DBR *ar) = 0;
 253 #endif
 254 };
 255
 256 #endif /* __Bbdb_H_ */