]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/mysql.c
Cleanup new timeout code for bconsole
[bacula/bacula] / bacula / src / cats / mysql.c
1 /*
2    Bacula® - The Network Backup Solution
3
4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
5
6    The main author of Bacula is Kern Sibbald, with contributions from
7    many others, a complete list can be found in the file AUTHORS.
8    This program is Free Software; you can redistribute it and/or
9    modify it under the terms of version two of the GNU General Public
10    License as published by the Free Software Foundation and included
11    in the file LICENSE.
12
13    This program is distributed in the hope that it will be useful, but
14    WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16    General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21    02110-1301, USA.
22
23    Bacula® is a registered trademark of Kern Sibbald.
24    The licensor of Bacula is the Free Software Foundation Europe
25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26    Switzerland, email:ftf@fsfeurope.org.
27 */
28 /*
29  * Bacula Catalog Database routines specific to MySQL
30  *   These are MySQL specific routines -- hopefully all
31  *    other files are generic.
32  *
33  *    Kern Sibbald, March 2000
34  *
35  *    Version $Id$
36  */
37
38
39 /* The following is necessary so that we do not include
40  * the dummy external definition of DB.
41  */
42 #define __SQL_C                       /* indicate that this is sql.c */
43
44 #include "bacula.h"
45 #include "cats.h"
46
47 #ifdef HAVE_MYSQL
48
49 /* -----------------------------------------------------------------------
50  *
51  *   MySQL dependent defines and subroutines
52  *
53  * -----------------------------------------------------------------------
54  */
55
56 /* List of open databases */
57 static BQUEUE db_list = {&db_list, &db_list};
58
59 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
60
61 /*
62  * Retrieve database type
63  */
64 const char *
65 db_get_type(void)
66 {
67    return "MySQL";
68 }
69
70 /*
71  * Initialize database data structure. In principal this should
72  * never have errors, or it is really fatal.
73  */
74 B_DB *
75 db_init_database(JCR *jcr, const char *db_name, const char *db_user, const char *db_password,
76                  const char *db_address, int db_port, const char *db_socket,
77                  int mult_db_connections)
78 {
79    B_DB *mdb;
80
81    if (!db_user) {
82       Jmsg(jcr, M_FATAL, 0, _("A user name for MySQL must be supplied.\n"));
83       return NULL;
84    }
85    P(mutex);                          /* lock DB queue */
86    /* Look to see if DB already open */
87    if (!mult_db_connections) {
88       for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
89          if (bstrcmp(mdb->db_name, db_name) &&
90              bstrcmp(mdb->db_address, db_address) &&
91              mdb->db_port == db_port) {
92             Dmsg2(100, "DB REopen %d %s\n", mdb->ref_count, db_name);
93             mdb->ref_count++;
94             V(mutex);
95             Dmsg3(100, "initdb ref=%d connected=%d db=%p\n", mdb->ref_count,
96                   mdb->connected, mdb->db);
97             return mdb;                  /* already open */
98          }
99       }
100    }
101    Dmsg0(100, "db_open first time\n");
102    mdb = (B_DB *)malloc(sizeof(B_DB));
103    memset(mdb, 0, sizeof(B_DB));
104    mdb->db_name = bstrdup(db_name);
105    mdb->db_user = bstrdup(db_user);
106    if (db_password) {
107       mdb->db_password = bstrdup(db_password);
108    }
109    if (db_address) {
110       mdb->db_address = bstrdup(db_address);
111    }
112    if (db_socket) {
113       mdb->db_socket = bstrdup(db_socket);
114    }
115    mdb->db_port = db_port;
116    mdb->have_insert_id = true;
117    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
118    *mdb->errmsg = 0;
119    mdb->cmd = get_pool_memory(PM_EMSG);    /* get command buffer */
120    mdb->cached_path = get_pool_memory(PM_FNAME);
121    mdb->cached_path_id = 0;
122    mdb->ref_count = 1;
123    mdb->fname = get_pool_memory(PM_FNAME);
124    mdb->path = get_pool_memory(PM_FNAME);
125    mdb->esc_name = get_pool_memory(PM_FNAME);
126    mdb->esc_path = get_pool_memory(PM_FNAME);
127    mdb->allow_transactions = mult_db_connections;
128    qinsert(&db_list, &mdb->bq);            /* put db in list */
129    Dmsg3(100, "initdb ref=%d connected=%d db=%p\n", mdb->ref_count,
130          mdb->connected, mdb->db);
131    V(mutex);
132    return mdb;
133 }
134
135 /*
136  * Now actually open the database.  This can generate errors,
137  *  which are returned in the errmsg
138  *
139  * DO NOT close the database or free(mdb) here !!!!
140  */
141 int
142 db_open_database(JCR *jcr, B_DB *mdb)
143 {
144    int errstat;
145
146    P(mutex);
147    if (mdb->connected) {
148       V(mutex);
149       return 1;
150    }
151
152    if ((errstat=rwl_init(&mdb->lock)) != 0) {
153       berrno be;
154       Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
155             be.bstrerror(errstat));
156       V(mutex);
157       return 0;
158    }
159
160    /* connect to the database */
161 #ifdef xHAVE_EMBEDDED_MYSQL
162 // mysql_server_init(0, NULL, NULL);
163 #endif
164    mysql_init(&mdb->mysql);
165
166    Dmsg0(50, "mysql_init done\n");
167    /* If connection fails, try at 5 sec intervals for 30 seconds. */
168    for (int retry=0; retry < 6; retry++) {
169       mdb->db = mysql_real_connect(
170            &(mdb->mysql),                /* db */
171            mdb->db_address,              /* default = localhost */
172            mdb->db_user,                 /*  login name */
173            mdb->db_password,             /*  password */
174            mdb->db_name,                 /* database name */
175            mdb->db_port,                 /* default port */
176            mdb->db_socket,               /* default = socket */
177            CLIENT_FOUND_ROWS);           /* flags */
178
179       /* If no connect, try once more in case it is a timing problem */
180       if (mdb->db != NULL) {
181          break;
182       }
183       bmicrosleep(5,0);
184    }
185
186    mdb->mysql.reconnect = 1;             /* so connection does not timeout */
187    Dmsg0(50, "mysql_real_connect done\n");
188    Dmsg3(50, "db_user=%s db_name=%s db_password=%s\n", mdb->db_user, mdb->db_name,
189             mdb->db_password==NULL?"(NULL)":mdb->db_password);
190
191    if (mdb->db == NULL) {
192       Mmsg2(&mdb->errmsg, _("Unable to connect to MySQL server.\n"
193 "Database=%s User=%s\n"
194 "MySQL connect failed either server not running or your authorization is incorrect.\n"),
195          mdb->db_name, mdb->db_user);
196 #if MYSQL_VERSION_ID >= 40101
197       Dmsg3(50, "Error %u (%s): %s\n",
198             mysql_errno(&(mdb->mysql)), mysql_sqlstate(&(mdb->mysql)),
199             mysql_error(&(mdb->mysql)));
200 #else
201       Dmsg2(50, "Error %u: %s\n",
202             mysql_errno(&(mdb->mysql)), mysql_error(&(mdb->mysql)));
203 #endif
204       V(mutex);
205       return 0;
206    }
207
208    mdb->connected = true;
209    if (!check_tables_version(jcr, mdb)) {
210       V(mutex);
211       return 0;
212    }
213
214    Dmsg3(100, "opendb ref=%d connected=%d db=%p\n", mdb->ref_count,
215          mdb->connected, mdb->db);
216
217    /* Set connection timeout to 8 days specialy for batch mode */
218    sql_query(mdb, "SET wait_timeout=691200");
219    sql_query(mdb, "SET interactive_timeout=691200");
220
221    V(mutex);
222    return 1;
223 }
224
225 void
226 db_close_database(JCR *jcr, B_DB *mdb)
227 {
228    if (!mdb) {
229       return;
230    }
231    db_end_transaction(jcr, mdb);
232    P(mutex);
233    sql_free_result(mdb);
234    mdb->ref_count--;
235    Dmsg3(100, "closedb ref=%d connected=%d db=%p\n", mdb->ref_count,
236          mdb->connected, mdb->db);
237    if (mdb->ref_count == 0) {
238       qdchain(&mdb->bq);
239       if (mdb->connected) {
240          Dmsg1(100, "close db=%p\n", mdb->db);
241          mysql_close(&mdb->mysql);
242
243 #ifdef xHAVE_EMBEDDED_MYSQL
244 //       mysql_server_end();
245 #endif
246       }
247       rwl_destroy(&mdb->lock);
248       free_pool_memory(mdb->errmsg);
249       free_pool_memory(mdb->cmd);
250       free_pool_memory(mdb->cached_path);
251       free_pool_memory(mdb->fname);
252       free_pool_memory(mdb->path);
253       free_pool_memory(mdb->esc_name);
254       free_pool_memory(mdb->esc_path);
255       if (mdb->db_name) {
256          free(mdb->db_name);
257       }
258       if (mdb->db_user) {
259          free(mdb->db_user);
260       }
261       if (mdb->db_password) {
262          free(mdb->db_password);
263       }
264       if (mdb->db_address) {
265          free(mdb->db_address);
266       }
267       if (mdb->db_socket) {
268          free(mdb->db_socket);
269       }
270       free(mdb);
271    }
272    V(mutex);
273 }
274
275 /*
276  * This call is needed because the message channel thread
277  *  opens a database on behalf of a jcr that was created in
278  *  a different thread. MySQL then allocates thread specific
279  *  data, which is NOT freed when the original jcr thread
280  *  closes the database.  Thus the msgchan must call here
281  *  to cleanup any thread specific data that it created.
282  */
283 void db_thread_cleanup()
284
285 #ifndef HAVE_WIN32
286    my_thread_end();
287 #endif
288 }
289
290 /*
291  * Return the next unique index (auto-increment) for
292  * the given table.  Return NULL on error.
293  *
294  * For MySQL, NULL causes the auto-increment value
295  *  to be updated.
296  */
297 int db_next_index(JCR *jcr, B_DB *mdb, char *table, char *index)
298 {
299    strcpy(index, "NULL");
300    return 1;
301 }
302
303
304 /*
305  * Escape strings so that MySQL is happy
306  *
307  *   NOTE! len is the length of the old string. Your new
308  *         string must be long enough (max 2*old+1) to hold
309  *         the escaped output.
310  */
311 void
312 db_escape_string(JCR *jcr, B_DB *mdb, char *snew, char *old, int len)
313 {
314    mysql_real_escape_string(mdb->db, snew, old, len);
315 }
316
317 /*
318  * Submit a general SQL command (cmd), and for each row returned,
319  *  the sqlite_handler is called with the ctx.
320  */
321 bool db_sql_query(B_DB *mdb, const char *query, DB_RESULT_HANDLER *result_handler, void *ctx)
322 {
323    SQL_ROW row;
324    bool send = true;
325
326    db_lock(mdb);
327    if (sql_query(mdb, query) != 0) {
328       Mmsg(mdb->errmsg, _("Query failed: %s: ERR=%s\n"), query, sql_strerror(mdb));
329       db_unlock(mdb);
330       return false;
331    }
332    if (result_handler != NULL) {
333       if ((mdb->result = sql_use_result(mdb)) != NULL) {
334          int num_fields = sql_num_fields(mdb);
335
336          /* We *must* fetch all rows */
337          while ((row = sql_fetch_row(mdb)) != NULL) {
338             if (send) {
339                /* the result handler returns 1 when it has
340                 *  seen all the data it wants.  However, we
341                 *  loop to the end of the data.
342                 */
343                if (result_handler(ctx, num_fields, row)) {
344                   send = false;
345                }
346             }
347          }
348
349          sql_free_result(mdb);
350       }
351    }
352    db_unlock(mdb);
353    return true;
354
355 }
356
357 void my_mysql_free_result(B_DB *mdb)
358 {
359    db_lock(mdb);
360    if (mdb->result) {
361       mysql_free_result(mdb->result);
362       mdb->result = NULL;
363    }
364    db_unlock(mdb);
365 }
366
367 #ifdef HAVE_BATCH_FILE_INSERT
368 const char *my_mysql_batch_lock_path_query = 
369    "LOCK TABLES Path write, batch write, Path as p write";
370
371
372 const char *my_mysql_batch_lock_filename_query = 
373    "LOCK TABLES Filename write, batch write, Filename as f write";
374
375 const char *my_mysql_batch_unlock_tables_query = "UNLOCK TABLES";
376
377 const char *my_mysql_batch_fill_path_query = 
378    "INSERT INTO Path (Path) "
379     "SELECT a.Path FROM " 
380      "(SELECT DISTINCT Path FROM batch) AS a WHERE NOT EXISTS "
381      "(SELECT Path FROM Path AS p WHERE p.Path = a.Path)";     
382
383 const char *my_mysql_batch_fill_filename_query = 
384    "INSERT INTO Filename (Name) "
385     "SELECT a.Name FROM " 
386      "(SELECT DISTINCT Name FROM batch) AS a WHERE NOT EXISTS "
387      "(SELECT Name FROM Filename AS f WHERE f.Name = a.Name)";
388 #endif /* HAVE_BATCH_FILE_INSERT */
389
390 #endif /* HAVE_MYSQL */