mirrors/urbackup_backend
2
0
Fork 0
mirror of https://github.com/uroni/urbackup_backend.git synced 2025-10-26 11:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
2.3.x
urbackup_backend/urbackupserver/dllmain.cpp

2507 lines
70 KiB
C++
Raw Permalink Blame History

/*************************************************************************
* UrBackup - Client/Server backup system
* Copyright (C) 2011-2016 Martin Raiber
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
**************************************************************************/
#include "../vld.h"
#ifdef _WIN32
#define DLLEXPORT extern "C" __declspec (dllexport)
#else
#define DLLEXPORT extern "C"
#endif
#include <vector>
#ifndef STATIC_PLUGIN
#define DEF_SERVER
#endif
#include "../Interface/Server.h"
#ifndef STATIC_PLUGIN
IServer *Server;
#else
#include "../StaticPluginRegistration.h"
extern IServer* Server;
#define LoadActions LoadActions_urbackupserver
#define UnloadActions UnloadActions_urbackupserver
#endif
#include "../Interface/Action.h"
#include "../Interface/Database.h"
#include "../Interface/SessionMgr.h"
#include "../Interface/Pipe.h"
#include "../Interface/Query.h"
#include "../Interface/Thread.h"
#include "../Interface/File.h"
#include "../fsimageplugin/IFSImageFactory.h"
#include "../cryptoplugin/ICryptoFactory.h"
#include "../urlplugin/IUrlFactory.h"
#include "../luaplugin/ILuaInterpreter.h"
#include "database.h"
#include "actions.h"
#include "serverinterface/actions.h"
#include "serverinterface/helper.h"
SStartupStatus startup_status;
#include "server.h"
#include "ImageMount.h"
#include "../stringtools.h"
#include "server_status.h"
#include "server_log.h"
#include "server_cleanup.h"
#include "ClientMain.h"
#include "server_archive.h"
#include "server_settings.h"
#include "server_update_stats.h"
#include "../urbackupcommon/os_functions.h"
#include "InternetServiceConnector.h"
#include "filedownload.h"
#include "apps/cleanup_cmd.h"
#include "apps/repair_cmd.h"
#include "apps/export_auth_log.h"
#include "apps/skiphash_copy.h"
#include "apps/patch.h"
#include "create_files_index.h"
#include "server_dir_links.h"
#include "server_channel.h"
#include "DataplanDb.h"
#include "Alerts.h"
#include "Mailer.h"
#include <stdlib.h>
#include "../Interface/DatabaseCursor.h"
#include <set>
#include "apps/check_files_index.h"
#include "../fileservplugin/IFileServ.h"
#include "../fileservplugin/IFileServFactory.h"
#include "restore_client.h"
#include "../urbackupcommon/WalCheckpointThread.h"
#include "FileMetadataDownloadThread.h"
#include "../urbackupcommon/chunk_hasher.h"
#include "LogReport.h"
#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
#include "../common/miniz.h"
namespace
{
#include "backup_server_db.h"
std::string get_backup_server_db_data()
{
size_t out_len;
void* cdata = tinfl_decompress_mem_to_heap(backup_server_db_z, backup_server_db_z_len, &out_len, TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32);
if (cdata == NULL)
{
return std::string();
}
std::string ret(reinterpret_cast<char*>(cdata), reinterpret_cast<char*>(cdata) + out_len);
mz_free(cdata);
return ret;
}
}
IPipe *server_exit_pipe=NULL;
IFSImageFactory *image_fak;
ICryptoFactory *crypto_fak;
IUrlFactory *url_fak=NULL;
IFileServ* fileserv=NULL;
ILuaInterpreter* lua_interpreter = NULL;
std::string server_identity;
std::string server_token;
const unsigned short serviceport=35623;
#define ADD_ACTION(x) { IAction *na=new Actions::x;\
Server->AddAction( na );\
gActions.push_back(na); }
std::vector<IAction*> gActions;
void init_mutex1(void);
void destroy_mutex1(void);
void writeZeroblockdata(void);
bool testEscape(void);
void upgrade(void);
bool test_amatch(void);
bool test_amatch(void);
bool verify_hashes(std::string arg);
void updateRights(int t_userid, std::string s_rights, IDatabase *db);
int md5sum_check();
std::string lang="en";
std::string time_format_str="%Y-%m-%d %H:%M";
std::string time_format_str_de=time_format_str;
THREADPOOL_TICKET tt_cleanup_thread;
THREADPOOL_TICKET tt_automatic_archive_thread;
bool is_leak_check=false;
const size_t sqlite_data_allocation_chunk_size = 50*1024*1024; //50MB
#ifdef _WIN32
const std::string new_file="new.txt";
#else
const std::string new_file="urbackup/new.txt";
#endif
void open_server_database(bool init_db)
{
if( !FileExists("urbackup/backup_server.db") && init_db )
{
writestring(get_backup_server_db_data(), "urbackup/backup_server.db");
}
std::string sqlite_mmap_huge = Server->getServerParameter("sqlite_mmap_huge");
std::string sqlite_mmap_medium = Server->getServerParameter("sqlite_mmap_medium");
std::string sqlite_mmap_small = Server->getServerParameter("sqlite_mmap_small");
str_map params;
params["wal_autocheckpoint"] = "0";
if (!sqlite_mmap_medium.empty())
{
params["mmap_size"] = sqlite_mmap_medium;
}
if(! Server->openDatabase("urbackup/backup_server.db", URBACKUPDB_SERVER, params) )
{
Server->Log("Couldn't open Database backup_server.db. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_medium.empty())
{
params.erase(params.find("mmap_size"));
}
Server->setDatabaseAllocationChunkSize(URBACKUPDB_SERVER, sqlite_data_allocation_chunk_size);
if(!Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER))
{
Server->Log("Couldn't open backup server database. Exiting. Expecting database at \""+
Server->getServerWorkingDir()+os_file_sep()+"urbackup"+os_file_sep()+"backup_server.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_huge.empty())
{
params["mmap_size"] = sqlite_mmap_huge;
}
if (!Server->openDatabase("urbackup/backup_server_files.db", URBACKUPDB_SERVER_FILES, params))
{
Server->Log("Couldn't open Database backup_server_files.db. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_files.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_huge.empty())
{
params.erase(params.find("mmap_size"));
}
str_map params_nil;
if (!Server->openDatabase("urbackup/backup_server_files.db", URBACKUPDB_SERVER_FILES_DEL, params_nil))
{
Server->Log("Couldn't open Database backup_server_files.db (2). Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_files.db\"", LL_ERROR);
exit(1);
}
Server->setDatabaseAllocationChunkSize(URBACKUPDB_SERVER_FILES, sqlite_data_allocation_chunk_size);
if (!Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER_FILES))
{
Server->Log("Couldn't open backup server database. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_files.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_small.empty())
{
params["mmap_size"] = sqlite_mmap_small;
}
if (!Server->openDatabase("urbackup/backup_server_link_journal.db", URBACKUPDB_SERVER_LINK_JOURNAL, params))
{
Server->Log("Couldn't open Database backup_server_link_journal.db. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_link_journal.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_small.empty())
{
params.erase(params.find("mmap_size"));
}
Server->setDatabaseAllocationChunkSize(URBACKUPDB_SERVER_LINK_JOURNAL, sqlite_data_allocation_chunk_size);
if (!Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER_LINK_JOURNAL))
{
Server->Log("Couldn't open backup server database. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_link_journal.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_medium.empty())
{
params["mmap_size"] = sqlite_mmap_small;
}
if (!Server->openDatabase("urbackup/backup_server_links.db", URBACKUPDB_SERVER_LINKS, params))
{
Server->Log("Couldn't open Database backup_server_links.db. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_links.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_medium.empty())
{
params.erase(params.find("mmap_size"));
}
Server->setDatabaseAllocationChunkSize(URBACKUPDB_SERVER_LINKS, sqlite_data_allocation_chunk_size);
if (!Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER_LINKS))
{
Server->Log("Couldn't open backup server database. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_links.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_small.empty())
{
params["mmap_size"] = sqlite_mmap_small;
}
if (!Server->openDatabase("urbackup/backup_server_settings.db", URBACKUPDB_SERVER_SETTINGS, params))
{
Server->Log("Couldn't open Database backup_server_settings.db. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_settings.db\"", LL_ERROR);
exit(1);
}
if (!sqlite_mmap_small.empty())
{
params.erase(params.find("mmap_size"));
}
Server->setDatabaseAllocationChunkSize(URBACKUPDB_SERVER_SETTINGS, sqlite_data_allocation_chunk_size);
if (!Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER_SETTINGS))
{
Server->Log("Couldn't open backup server database. Exiting. Expecting database at \"" +
Server->getServerWorkingDir() + os_file_sep() + "urbackup" + os_file_sep() + "backup_server_settings.db\"", LL_ERROR);
exit(1);
}
Server->destroyDatabases(Server->getThreadID());
}
void open_settings_database()
{
std::string aname="urbackup/backup_server_settings.db";
Server->attachToDatabase(aname, "settings_db", URBACKUPDB_SERVER);
}
void start_wal_checkpoint_threads()
{
WalCheckpointThread* wal_checkpoint_thread = new WalCheckpointThread(100 * 1024 * 1024, 1000 * 1024 * 1024,
"urbackup" + os_file_sep() + "backup_server_files.db", URBACKUPDB_SERVER_FILES);
Server->createThread(wal_checkpoint_thread, "files checkpoint");
wal_checkpoint_thread = new WalCheckpointThread(10 * 1024 * 1024, 100 * 1024 * 1024,
"urbackup" + os_file_sep() + "backup_server.db", URBACKUPDB_SERVER, "main");
Server->createThread(wal_checkpoint_thread, "main checkpoint");
wal_checkpoint_thread = new WalCheckpointThread(10 * 1024 * 1024, 100 * 1024 * 1024,
"urbackup" + os_file_sep() + "backup_server_settings.db", URBACKUPDB_SERVER);
Server->createThread(wal_checkpoint_thread, "settings checkpoint");
wal_checkpoint_thread = new WalCheckpointThread(10 * 1024 * 1024, 100 * 1024 * 1024,
"urbackup" + os_file_sep() + "backup_server_link_journal.db", URBACKUPDB_SERVER_LINK_JOURNAL);
Server->createThread(wal_checkpoint_thread, "lnk jour checkpoint");
wal_checkpoint_thread = new WalCheckpointThread(100 * 1024 * 1024, 1000 * 1024 * 1024,
"urbackup" + os_file_sep() + "backup_server_links.db", URBACKUPDB_SERVER_LINKS);
Server->createThread(wal_checkpoint_thread, "lnk checkpoint");
}
bool attach_other_dbs(IDatabase* db)
{
if (!db->Write("ATTACH DATABASE 'urbackup/backup_server_files.db' AS files_db"))
{
return false;
}
if (!db->Write("ATTACH DATABASE 'urbackup/backup_server_link_journal.db' AS link_journal_db"))
{
return false;
}
if (!db->Write("ATTACH DATABASE 'urbackup/backup_server_links.db' AS links_db"))
{
return false;
}
return true;
}
void detach_other_dbs(IDatabase* db)
{
db->Write("DETACH DATABASE files_db");
db->Write("DETACH DATABASE link_journal_db");
db->Write("DETACH DATABASE links_db");
}
DLLEXPORT void LoadActions(IServer* pServer)
{
Server=pServer;
/*if(!testEscape())
{
Server->Log("Escape test failed! Stopping.", LL_ERROR);
return;
}*/
/*if(!test_amatch())
{
Server->Log("Amatch test failed! Stopping.", LL_ERROR);
return;
}*/
/*if(!test_amatch())
{
Server->Log("Amatch test failed! Stopping.", LL_ERROR);
return;
}*/
std::string rmtest=Server->getServerParameter("rmtest");
if(!rmtest.empty())
{
os_remove_nonempty_dir(rmtest);
return;
}
if (Server->getServerParameter("run-test") == "true")
{
exit(0);
}
std::string download_file=Server->getServerParameter("download_file");
if(!download_file.empty())
{
/* For attaching debugger
std::cout << "Process id: " << GetCurrentProcessId() << std::endl;
system("pause");*/
unsigned int tcpport=43001;
std::string s_tcpport=Server->getServerParameter("tcpport");
if(!s_tcpport.empty()) tcpport=atoi(s_tcpport.c_str());
int method=0;
std::string s_method=Server->getServerParameter("method");
if(!s_method.empty()) method=atoi(s_method.c_str());
FileDownload dl(Server->getServerParameter("servername"), tcpport);
int predicted_filesize = atoi(Server->getServerParameter("predicted_filesize", "-1").c_str());
Server->Log("Starting file download... (predicted_filesize="+convert(predicted_filesize)+")");
dl.filedownload(download_file, Server->getServerParameter("dstfn"), method, predicted_filesize, SQueueStatus_NoQueue);
exit(1);
}
std::string download_file_csv=Server->getServerParameter("download_file_csv");
if(!download_file_csv.empty())
{
/* For attaching debugger
std::cout << "Process id: " << GetCurrentProcessId() << std::endl;
system("pause");*/
unsigned int tcpport=43001;
std::string s_tcpport=Server->getServerParameter("tcpport");
if(!s_tcpport.empty()) tcpport=atoi(s_tcpport.c_str());
FileDownload dl(Server->getServerParameter("servername"), tcpport);
dl.filedownload(download_file_csv);
exit(1);
}
init_mutex1();
ServerLogger::init_mutex();
init_dir_link_mutex();
WalCheckpointThread::init_mutex();
std::string app=Server->getServerParameter("app", "");
if(!app.empty())
{
int rc=0;
if(app=="cleanup")
{
rc=cleanup_cmd();
}
else if(app=="remove_unknown")
{
rc=remove_unknown();
}
else if(app=="cleanup_database")
{
rc=cleanup_database();
}
else if(app=="repair_database")
{
rc=repair_cmd();
}
else if(app=="defrag_database")
{
rc=defrag_database();
}
else if(app=="export_auth_log")
{
rc=export_auth_log();
}
else if(app=="check_fileindex")
{
rc=check_files_index();
}
else if(app=="check_metadata")
{
rc=server::check_metadata();
}
else if(app=="skiphash_copy")
{
rc=skiphash_copy_file();
}
else if (app == "md5sum_check")
{
rc = md5sum_check();
}
else if (app == "patch_hash")
{
rc = patch_hash();
}
else if (app == "hash")
{
std::auto_ptr<IFsFile> f(Server->openFile(Server->getServerParameter("hash_file"), MODE_READ_SEQUENTIAL));
if (f.get() != NULL)
{
std::string h = BackupServerPrepareHash::calc_hash(f.get(), Server->getServerParameter("hash_method"));
Server->Log("Hash: " + base64_encode(reinterpret_cast<const unsigned char*>(h.data()), static_cast<unsigned int>(h.size())), LL_INFO);
}
else
{
Server->Log("Cannot open file to hash (hash_file) \"" + Server->getServerParameter("hash_file") + "\" for reading. " + os_last_error_str(), LL_ERROR);
}
}
else
{
rc=100;
Server->Log("App not found. Available apps: cleanup, remove_unknown, cleanup_database, repair_database, defrag_database, export_auth_log, check_fileindex, skiphash_copy, md5sum_check, hash");
}
exit(rc);
}
#ifdef _WIN32
char t_lang[20];
GetLocaleInfoA(LOCALE_SYSTEM_DEFAULT,LOCALE_SISO639LANGNAME ,t_lang,sizeof(t_lang));
lang=t_lang;
#endif
if(lang=="de")
{
time_format_str=time_format_str_de;
}
{
str_map params;
crypto_fak=(ICryptoFactory *)Server->getPlugin(Server->getThreadID(), Server->StartPlugin("cryptoplugin", params));
if( crypto_fak==NULL )
{
Server->Log("Error loading Cryptoplugin. Internet service will not work.", LL_ERROR);
}
}
//writeZeroblockdata();
if((server_identity=getFile("urbackup/server_ident.key")).size()<5)
{
Server->Log("Generating Server identity...", LL_INFO);
std::string ident="#I"+ServerSettings::generateRandomAuthKey(20)+"#";
writestring(ident, "urbackup/server_ident.key");
server_identity=ident;
}
if(FileExists("urbackup/server_ident_ecdsa409k1.pub") && crypto_fak!=NULL)
{
std::string signature;
if(!crypto_fak->signData(getFile("urbackup/server_ident_ecdsa409k1.priv"), "test", signature))
{
Server->Log("Server ECDSA identity broken. Regenerating...", LL_ERROR);
Server->deleteFile("urbackup/server_ident_ecdsa409k1.pub");
Server->deleteFile("urbackup/server_ident_ecdsa409k1.priv");
}
}
if(!FileExists("urbackup/server_ident_ecdsa409k1.pub") && crypto_fak!=NULL)
{
Server->Log("Generating Server private/public ECDSA key...", LL_INFO);
crypto_fak->generatePrivatePublicKeyPair("urbackup/server_ident_ecdsa409k1");
}
if(FileExists("urbackup/server_ident.pub") && crypto_fak!=NULL)
{
std::string signature;
if(!crypto_fak->signDataDSA(getFile("urbackup/server_ident.priv"), "test", signature))
{
Server->Log("Server DSA identity broken. Regenerating...", LL_ERROR);
Server->deleteFile("urbackup/server_ident.pub");
Server->deleteFile("urbackup/server_ident.priv");
}
}
if(!FileExists("urbackup/server_ident.pub") && crypto_fak!=NULL)
{
Server->Log("Generating Server private/public DSA key...", LL_INFO);
crypto_fak->generatePrivatePublicKeyPairDSA("urbackup/server_ident");
}
if((server_token=getFile("urbackup/server_token.key")).size()<5)
{
Server->Log("Generating Server token...", LL_INFO);
std::string token=ServerSettings::generateRandomAuthKey(20);
writestring(token, "urbackup/server_token.key");
server_token=token;
}
Server->deleteFile("urbackup/shutdown_now");
{
str_map params;
image_fak=(IFSImageFactory *)Server->getPlugin(Server->getThreadID(), Server->StartPlugin("fsimageplugin", params));
if( image_fak==NULL )
{
Server->Log("Error loading fsimageplugin", LL_ERROR);
}
}
{
str_map params;
IFileServFactory* fileserv_fak=(IFileServFactory *)Server->getPlugin(Server->getThreadID(), Server->StartPlugin("fileserv", params));
if( fileserv_fak==NULL )
{
Server->Log("Error loading fileservplugin. File restores won't work.", LL_ERROR);
}
else
{
fileserv = fileserv_fak->createFileServNoBind(std::string(), false, false, false);
}
}
{
str_map params;
lua_interpreter = dynamic_cast<ILuaInterpreter*>(Server->getPlugin(Server->getThreadID(), Server->StartPlugin("lua", params)));
if (lua_interpreter == NULL)
{
Server->Log("Lua plugin missing. Alerts won't work.", LL_WARNING);
}
}
open_server_database(true);
ServerStatus::init_mutex();
ServerSettings::init_mutex();
ClientMain::init_mutex();
DataplanDb::init();
init_log_report();
open_settings_database();
std::string arg_verify_hashes=Server->getServerParameter("verify_hashes");
if(!arg_verify_hashes.empty())
{
if(!verify_hashes(arg_verify_hashes))
{
Server->Log("Backup verification failed! See verification_result.txt for more info.", LL_ERROR);
exit(1);
}
else
{
Server->Log("Backup verification successful.", LL_INFO);
Server->deleteFile("verification_result.txt");
exit(0);
}
}
Server->destroyAllDatabases();
startup_status.mutex=Server->createMutex();
{
IScopedLock lock(startup_status.mutex);
startup_status.upgrading_database=true;
}
ADD_ACTION(login);
upgrade();
std::vector<DATABASE_ID> dbs;
dbs.push_back(URBACKUPDB_SERVER);
dbs.push_back(URBACKUPDB_SERVER_FILES);
dbs.push_back(URBACKUPDB_SERVER_LINKS);
dbs.push_back(URBACKUPDB_SERVER_LINK_JOURNAL);
for (size_t i = 0; i < dbs.size(); ++i)
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), dbs[i]);
db->Write("PRAGMA journal_mode=WAL");
}
if( FileExists("urbackup/backupfolder")
#ifndef _WIN32
|| FileExists("/etc/urbackup/backupfolder")
#endif
)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db_results res=db->Read("SELECT value FROM settings_db.settings WHERE key='backupfolder' AND clientid=0");
if(res.empty())
{
IQuery *q=db->Prepare("INSERT INTO settings_db.settings (key, value, clientid) VALUES ('backupfolder', ?, 0)", false);
std::string bf=getFile("urbackup/backupfolder");
#ifndef _WIN32
if (bf.empty())
{
bf = getFile("/etc/urbackup/backupfolder");
}
#endif
if(linecount(bf)>0)
bf=getline(0, bf);
q->Bind(trim(bf));
q->Write();
db->destroyQuery(q);
ServerSettings::updateAll();
}
}
if(!create_files_index(startup_status))
{
Server->Log("Could not create or open file entry index. Exiting.", LL_ERROR);
exit(1);
}
{
IScopedLock lock(startup_status.mutex);
startup_status.upgrading_database=false;
}
std::string set_admin_pw=Server->getServerParameter("set_admin_pw");
if(!set_admin_pw.empty())
{
std::string set_admin_username = Server->getServerParameter("set_admin_username");
if(set_admin_username.empty())
{
set_admin_username = "admin";
}
std::string new_salt=ServerSettings::generateRandomAuthKey(20);
const size_t pbkdf2_rounds = 10000;
std::string password_md5 = strlower(crypto_fak->generatePasswordHash(hexToBytes(Server->GenerateHexMD5(new_salt+set_admin_pw)),
new_salt, pbkdf2_rounds));
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
IQuery* q_read = db->Prepare("SELECT password_md5 FROM settings_db.si_users WHERE name=?");
q_read->Bind(set_admin_username);
db_results res = q_read->Read();
q_read->Reset();
if(res.empty())
{
IQuery *q=db->Prepare("INSERT INTO settings_db.si_users (name, password_md5, salt, pbkdf2_rounds) VALUES (?,?,?,?)");
q->Bind(set_admin_username);
q->Bind(password_md5);
q->Bind(new_salt);
q->Bind(pbkdf2_rounds);
q->Write();
q->Reset();
Server->Log("User account \""+set_admin_username+"\" not present. Created admin user account with specified password.", LL_INFO);
}
else
{
IQuery *q=db->Prepare("UPDATE si_users SET password_md5=?, salt=?, pbkdf2_rounds=? WHERE name=?");
q->Bind(password_md5);
q->Bind(new_salt);
q->Bind(pbkdf2_rounds);
q->Bind(set_admin_username);
q->Write();
q->Reset();
Server->Log("Changed admin password.", LL_INFO);
}
{
IQuery *q=db->Prepare("SELECT id FROM si_users WHERE name=?");
q->Bind(set_admin_username);
db_results res = q->Read();
q->Reset();
if(!res.empty())
{
updateRights(watoi(res[0]["id"]), "idx=0&0_domain=all&0_right=all", db);
Server->Log("Updated admin rights.", LL_INFO);
}
}
db->destroyAllQueries();
exit(0);
}
ADD_ACTION(server_status);
ADD_ACTION(progress);
ADD_ACTION(salt);
ADD_ACTION(lastacts);
ADD_ACTION(piegraph);
ADD_ACTION(usagegraph);
ADD_ACTION(usage);
ADD_ACTION(users);
ADD_ACTION(status);
ADD_ACTION(backups);
ADD_ACTION(settings);
ADD_ACTION(logs);
ADD_ACTION(getimage);
ADD_ACTION(download_client);
ADD_ACTION(livelog);
ADD_ACTION(start_backup);
ADD_ACTION(add_client);
ADD_ACTION(restore_prepare_wait);
ADD_ACTION(scripts);
ADD_ACTION(status_check);
if(Server->getServerParameter("allow_shutdown")=="true")
{
ADD_ACTION(shutdown);
}
replay_directory_link_journal();
Server->Log("Started UrBackup...", LL_INFO);
str_map params;
url_fak=(IUrlFactory*)Server->getPlugin(Server->getThreadID(), Server->StartPlugin("url", params));
if(url_fak==NULL)
{
Server->Log("Error loading IUrlFactory", LL_INFO);
}
ServerChannelThread::initOffset();
IDatabase* db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
if(crypto_fak==NULL
&& db->Read("SELECT * FROM settings_db.si_users WHERE pbkdf2_rounds>0").size()>0)
{
Server->Log("Encrypted user passwords need cryptoplugin. Cannot run without cryptoplugin", LL_ERROR);
exit(1);
}
server_exit_pipe=Server->createMemoryPipe();
BackupServer *backup_server=new BackupServer(server_exit_pipe);
Server->createThread(backup_server, "client discovery");
Server->wait(500);
InternetServiceConnector::init_mutex();
{
ServerSettings settings(Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER));
if(settings.getSettings()->internet_mode_enabled)
{
std::string tmp=Server->getServerParameter("internet_port", "");
unsigned int port;
if(!tmp.empty())
{
port=atoi(tmp.c_str());
}
else
{
port=settings.getSettings()->internet_server_port;
}
Server->StartCustomStreamService(new InternetService, "InternetService", port);
}
}
init_chunk_hasher();
ServerCleanupThread::initMutex();
ServerAutomaticArchive::initMutex();
ServerCleanupThread *server_cleanup=new ServerCleanupThread(CleanupAction());
Mailer::init();
Server->createThread(new Alerts, "alerts");
is_leak_check=(Server->getServerParameter("leak_check")=="true");
if(is_leak_check)
{
tt_cleanup_thread=Server->getThreadPool()->execute(server_cleanup, "backup cleanup");
tt_automatic_archive_thread=Server->getThreadPool()->execute(new ServerAutomaticArchive, "backup archival");
}
else
{
Server->createThread(server_cleanup, "backup cleanup");
Server->createThread(new ServerAutomaticArchive, "backup archival");
}
Server->createThread(new ImageMount, "image umount");
Server->setLogCircularBufferSize(20);
start_wal_checkpoint_threads();
Server->clearDatabases(Server->getThreadID());
Server->Log("UrBackup Server start up complete.", LL_INFO);
}
DLLEXPORT void UnloadActions(void)
{
unsigned int wtime=500;
if(is_leak_check)
wtime=10000;
bool shutdown_ok=false;
if(server_exit_pipe!=NULL)
{
std::string msg="exit";
int64 starttime=Server->getTimeMS();
while(msg!="ok" && Server->getTimeMS()-starttime<wtime)
{
server_exit_pipe->Write("exit");
Server->wait(100);
server_exit_pipe->Read(&msg, 0);
}
if(msg=="ok")
{
Server->destroy(server_exit_pipe);
BackupServer::cleanupThrottlers();
shutdown_ok=true;
}
}
ServerLogger::destroy_mutex();
if(is_leak_check)
{
std::vector<THREADPOOL_TICKET> tickets;
tickets.push_back(tt_automatic_archive_thread);
tickets.push_back(tt_cleanup_thread);
ServerCleanupThread::doQuit();
ServerAutomaticArchive::doQuit();
Server->getThreadPool()->waitFor(tickets);
ServerCleanupThread::destroyMutex();
ServerAutomaticArchive::destroyMutex();
if(!shutdown_ok)
{
Server->Log("Could not shut down server. Leaks expected.", LL_ERROR);
}
InternetServiceConnector::destroy_mutex();
destroy_mutex1();
Server->destroy(startup_status.mutex);
Server->Log("Deleting cached server settings...", LL_INFO);
ServerSettings::clear_cache();
ServerSettings::destroy_mutex();
ServerStatus::destroy_mutex();
WalCheckpointThread::destroy_mutex();
destroy_dir_link_mutex();
Server->wait(1000);
}
if(shutdown_ok)
{
ClientMain::destroy_mutex();
}
std::vector<DATABASE_ID> db_ids;
db_ids.push_back(URBACKUPDB_SERVER);
db_ids.push_back(URBACKUPDB_SERVER_FILES);
db_ids.push_back(URBACKUPDB_SERVER_LINKS);
db_ids.push_back(URBACKUPDB_SERVER_LINK_JOURNAL);
if (!shutdown_ok)
{
for (size_t i = 0; i < db_ids.size(); ++i)
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), db_ids[i]);
db->BeginWriteTransaction();
}
}
else
{
Server->destroyAllDatabases();
}
FileIndex::stop_accept();
FileIndex::flush();
}
#ifdef STATIC_PLUGIN
namespace
{
static RegisterPluginHelper register_plugin(LoadActions, UnloadActions, 20);
}
#endif
void update_file(IQuery *q_space_get, IQuery* q_space_update, IQuery *q_file_update, db_results &curr_r)
{
_i64 filesize=os_atoi64(curr_r[0]["filesize"]);
std::map<int, int> client_c;
for(size_t i=0;i<curr_r.size();++i)
{
int cid=watoi(curr_r[i]["clientid"]);
std::map<int, int>::iterator it=client_c.find(cid);
if(it==client_c.end())
{
client_c.insert(std::pair<int, int>(cid, 1));
}
else
{
++it->second;
}
if(i==0)
{
q_file_update->Bind(filesize);
q_file_update->Bind(os_atoi64(curr_r[i]["id"]));
q_file_update->Write();
q_file_update->Reset();
}
else
{
q_file_update->Bind(0);
q_file_update->Bind(os_atoi64(curr_r[i]["id"]));
q_file_update->Write();
q_file_update->Reset();
}
}
for(std::map<int, int>::iterator it=client_c.begin();it!=client_c.end();++it)
{
q_space_get->Bind(it->first);
db_results res=q_space_get->Read();
q_space_get->Reset();
if(!res.empty())
{
_i64 used=os_atoi64(res[0]["bytes_used_files"]);
used+=filesize/client_c.size();
q_space_update->Bind(used);
q_space_update->Bind(it->first);
q_space_update->Write();
q_space_update->Reset();
}
}
}
void upgrade_1(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE files ADD rsize INTEGER");
db->Write("ALTER TABLE files ADD did_count INTEGER");
db->Write("ALTER TABLE clients ADD bytes_used_files INTEGER");
db->Write("ALTER TABLE clients ADD bytes_used_images INTEGER");
db->Write("UPDATE clients SET bytes_used_files=0 WHERE bytes_used_files IS NULL");
db->Write("UPDATE clients SET bytes_used_images=0 WHERE bytes_used_images IS NULL");
db->Write("UPDATE files SET did_count=1 WHERE did_count IS NULL");
IQuery *q_read=db->Prepare("SELECT files.rowid AS id, shahash, filesize, clientid FROM (files INNER JOIN backups ON files.backupid=backups.id) WHERE rsize IS NULL ORDER BY shahash DESC LIMIT 10000");
IQuery *q_space_get=db->Prepare("SELECT bytes_used_files FROM clients WHERE id=?");
IQuery *q_space_update=db->Prepare("UPDATE clients SET bytes_used_files=? WHERE id=?");
IQuery *q_file_update=db->Prepare("UPDATE files SET rsize=? WHERE rowid=?");
std::string filesize;
std::string shhash;
db_results curr_r;
int last_pc=0;
Server->Log("Updating client space usage...", LL_INFO);
db_results res;
do
{
res=q_read->Read();
q_read->Reset();
for(size_t j=0;j<res.size();++j)
{
if(shhash.empty() || (res[j]["shahash"]!=shhash || res[j]["filesize"]!=filesize ) )
{
if(!curr_r.empty())
{
update_file(q_space_get, q_space_update, q_file_update, curr_r);
}
curr_r.clear();
shhash=res[j]["shhash"];
filesize=res[j]["filesize"];
curr_r.push_back(res[j]);
}
int pc=(int)(((float)j/(float)res.size())*100.f+0.5f);
if(pc!=last_pc)
{
Server->Log(convert(pc)+"%", LL_INFO);
last_pc=pc;
}
}
}
while(!res.empty());
if(!curr_r.empty())
{
update_file(q_space_get, q_space_update, q_file_update, curr_r);
}
db->destroyAllQueries();
}
void upgrade1_2(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE logs ADD errors INTEGER");
db->Write("ALTER TABLE logs ADD warnings INTEGER");
db->Write("ALTER TABLE logs ADD infos INTEGER");
db->Write("ALTER TABLE logs ADD image INTEGER");
db->Write("ALTER TABLE logs ADD incremental INTEGER");
}
void upgrade2_3(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX IF NOT EXISTS clients_hist_created_idx ON clients_hist (created)");
}
void upgrade3_4(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX IF NOT EXISTS logs_created_idx ON logs (created)");
}
void upgrade4_5(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE extra_clients ( id INTEGER PRIMARY KEY, hostname TEXT, lastip INTEGER)");
}
void upgrade5_6(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE files_del ADD is_del INTEGER");
db->Write("UPDATE files_del SET is_del=1 WHERE is_del IS NULL");
}
void upgrade6_7(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backup_images ADD version INTEGER");
db->Write("UPDATE backup_images SET version=0 WHERE version IS NULL");
}
void upgrade7_8(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE clients ADD delete_pending INTEGER");
db->Write("UPDATE clients SET delete_pending=0 WHERE delete_pending IS NULL");
}
void upgrade8_9(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backup_images ADD letter TEXT");
db->Write("UPDATE backup_images SET letter='C:' WHERE letter IS NULL");
db->Write("CREATE TABLE assoc_images ( img_id INTEGER REFERENCES backup_images(id) ON DELETE CASCADE, assoc_id INTEGER REFERENCES backup_images(id) ON DELETE CASCADE)");
}
void upgrade9_10(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE si_users ADD report_mail TEXT");
db->Write("ALTER TABLE si_users ADD report_loglevel INTEGER");
db->Write("ALTER TABLE si_users ADD report_sendonly INTEGER");
}
void upgrade10_11(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE files ADD clientid INTEGER");
db->Write("UPDATE files SET clientid=(SELECT clientid FROM backups WHERE backups.id=backupid)");
}
void upgrade11_12(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("DROP INDEX files_idx");
db->Write("CREATE INDEX files_idx ON files (shahash, filesize, clientid)");
db->Write("CREATE INDEX files_did_count ON files (did_count)");
}
void upgrade12_13(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE files ADD incremental INTEGER");
db->Write("UPDATE files SET incremental=(SELECT incremental FROM backups WHERE backups.id=backupid)");
}
void upgrade13_14(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX files_backupid ON files (backupid)");
}
void upgrade14_15(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE settings_db.settings ("
"key TEXT,"
"value TEXT , clientid INTEGER);");
db->Write("CREATE TABLE settings_db.si_users"
"("
"id INTEGER PRIMARY KEY,"
"name TEXT,"
"password_md5 TEXT,"
"salt TEXT,"
"report_mail TEXT,"
"report_loglevel INTEGER,"
"report_sendonly INTEGER"
");");
db->Write("CREATE TABLE settings_db.si_permissions"
"("
"clientid INTEGER REFERENCES si_users(id) ON DELETE CASCADE,"
"t_right TEXT,"
"t_domain TEXT"
");");
db->Write("INSERT INTO settings_db.settings SELECT * FROM settings");
db->Write("INSERT INTO settings_db.si_users SELECT * FROM si_users");
db->Write("INSERT INTO settings_db.si_permissions SELECT * FROM si_permissions");
db->Write("DROP TABLE settings");
db->Write("DROP TABLE si_users");
db->Write("DROP TABLE si_permissions");
}
void upgrade15_16(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE settings_db.extra_clients ( id INTEGER PRIMARY KEY, hostname TEXT, lastip INTEGER)");
db->Write("INSERT INTO settings_db.extra_clients SELECT * FROM extra_clients");
db->Write("DROP TABLE extra_clients");
}
void upgrade16_17(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db_results res=db->Read("SELECT id FROM clients");
IQuery *q=db->Prepare("INSERT INTO settings_db.settings (key,value, clientid) VALUES ('internet_authkey',?,?)", false);
for(size_t i=0;i<res.size();++i)
{
std::string key=ServerSettings::generateRandomAuthKey();
q->Bind(key);
q->Bind(res[i]["id"]);
q->Write();
q->Reset();
}
db->destroyQuery(q);
}
void upgrade17_18(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE files ADD hashpath TEXT");
db->Write("ALTER TABLE files_del ADD hashpath TEXT");
}
void upgrade18_19(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backups ADD archived INTEGER");
db->Write("UPDATE backups SET archived=0 WHERE archived IS NULL");
}
void upgrade19_20(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE settings_db.automatic_archival ( id INTEGER PRIMARY KEY, next_archival INTEGER, interval INTEGER, interval_unit TEXT, length INTEGER, length_unit TEXT, backup_types INTEGER, clientid INTEGER)");
db->Write("ALTER TABLE backups ADD archive_timeout INTEGER");
}
void upgrade20_21(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE settings_db.automatic_archival ADD archive_window TEXT");
db->Write("UPDATE settings_db.automatic_archival SET archive_window='*;*;*;*' WHERE archive_window IS NULL");
}
void upgrade21_22(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX files_del_idx ON files_del (shahash, filesize, clientid)");
}
void upgrade22_23(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("INSERT INTO misc (tkey, tvalue) VALUES ('files_cache', 'none')");
db->Write("CREATE TABLE files_new ( backupid INTEGER, fullpath TEXT, hashpath TEXT, shahash BLOB, filesize INTEGER, created DATE DEFAULT CURRENT_TIMESTAMP, rsize INTEGER, clientid INTEGER, incremental INTEGER)");
}
void upgrade23_24(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db_results res=db->Read("SELECT value, clientid FROM settings_db.settings WHERE key='allow_starting_file_backups'");
IQuery *q_insert=db->Prepare("INSERT INTO settings_db.settings (key, value, clientid) VALUES (?, ?, ?)");
for(size_t i=0;i<res.size();++i)
{
q_insert->Bind("allow_starting_incr_file_backups");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
q_insert->Bind("allow_starting_full_file_backups");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
}
res=db->Read("SELECT value, clientid FROM settings_db.settings WHERE key='allow_starting_image_backups'");
q_insert=db->Prepare("INSERT INTO settings_db.settings (key, value, clientid) VALUES (?, ?, ?)");
for(size_t i=0;i<res.size();++i)
{
q_insert->Bind("allow_starting_incr_image_backups");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
q_insert->Bind("allow_starting_full_image_backups");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
}
}
void upgrade24_25(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backups ADD size_calculated INTEGER");
db->Write("UPDATE backups SET size_calculated=0 WHERE size_calculated IS NULL");
}
void upgrade25_26(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db_results res=db->Read("SELECT clientid, t_right FROM settings_db.si_permissions WHERE t_domain='settings'");
IQuery *q_insert=db->Prepare("INSERT INTO settings_db.si_permissions (t_domain, t_right, clientid) VALUES ('client_settings', ?, ?)");
for(size_t i=0;i<res.size();++i)
{
q_insert->Bind(res[i]["t_right"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
}
}
void upgrade26_27(void)
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db_results res=db->Read("SELECT value, clientid FROM settings_db.settings WHERE key='backup_window'");
IQuery *q_insert=db->Prepare("INSERT INTO settings_db.settings (key, value, clientid) VALUES (?, ?, ?)");
for(size_t i=0;i<res.size();++i)
{
q_insert->Bind("backup_window_incr_file");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
q_insert->Bind("backup_window_full_file");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
q_insert->Bind("backup_window_incr_image");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
q_insert->Bind("backup_window_full_image");
q_insert->Bind(res[i]["value"]);
q_insert->Bind(res[i]["clientid"]);
q_insert->Write();
q_insert->Reset();
}
}
void upgrade27_28()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX settings_db.settings_idx ON settings (key, clientid)");
db->Write("CREATE INDEX settings_db.si_users_idx ON si_users (name)");
db->Write("CREATE INDEX settings_db.si_permissions_idx ON si_permissions (clientid, t_domain)");
}
void upgrade28_29()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE directory_links ("
"id INTEGER PRIMARY KEY,"
"clientid INTGER,"
"name TEXT,"
"target TEXT)");
db->Write("CREATE INDEX directory_links_idx ON directory_links (clientid, name)");
db->Write("CREATE INDEX directory_links_target_idx ON directory_links (clientid, target)");
db->Write("CREATE TABLE directory_link_journal ("
"id INTEGER PRIMARY KEY,"
"linkname TEXT,"
"linktarget TEXT)");
}
void upgrade29_30()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE settings_db.login_access_log ("
"id INTEGER PRIMARY KEY,"
"logintime DATE DEFAULT CURRENT_TIMESTAMP,"
"username TEXT,"
"ip TEXT,"
"method INTEGER)");
}
void upgrade30_31()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE settings_db.old_backupfolders ("
"id INTEGER PRIMARY KEY,"
"backupfolder TEXT UNIQUE)");
}
void upgrade31_32()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backups ADD resumed INTEGER");
db->Write("UPDATE backups SET resumed=0 WHERE resumed IS NULL");
db->Write("ALTER TABLE logs ADD resumed INTEGER");
db->Write("UPDATE logs SET resumed=0 WHERE resumed IS NULL");
}
void upgrade32_33()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE TABLE orig_client_settings ("
"id INTEGER PRIMARY KEY,"
"clientid INTEGER UNIQUE,"
"data TEXT )");
}
void upgrade33_34()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("ALTER TABLE backups ADD indexing_time_ms INTEGER");
db->Write("UPDATE backups SET indexing_time_ms=0 WHERE indexing_time_ms IS NULL");
}
void upgrade34_35()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
db->Write("CREATE INDEX IF NOT EXISTS clients_hist_id_created_idx ON clients_hist_id (created)");
}
bool upgrade35_36()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
std::auto_ptr<IFile> db_file(Server->openFile("urbackup/backup_server.db", MODE_READ));
if(db_file.get() && Server->getServerParameter("override_freespace_check")==std::string())
{
int64 free_space = os_free_space(Server->getServerWorkingDir()+os_file_sep()+"urbackup");
int64 missing_free_space = db_file->Size()-free_space;
if(free_space<db_file->Size())
{
Server->Log("UrBackup needs "+PrettyPrintBytes(missing_free_space)+" more free space for the upgrade process. Please free up this amount of space at \""+Server->getServerWorkingDir()+os_file_sep()+"urbackup\"", LL_ERROR);
return false;
}
std::string tmpdir = db->getTempDirectoryPath();
if(!tmpdir.empty())
{
free_space = os_free_space(tmpdir);
int64 missing_free_space = db_file->Size()-free_space;
if(free_space<db_file->Size())
{
Server->Log("UrBackup needs "+PrettyPrintBytes(missing_free_space)+" more free space for the upgrade process at the temporary location. "
"Please free up this amount of space at \""+tmpdir+"\"", LL_ERROR);
return false;
}
}
}
db_file.reset();
if(!db->Write("ALTER TABLE files RENAME TO files_bck"))
{
return false;
}
if(!db->Write("DROP INDEX files_idx") ||
!db->Write("DROP INDEX files_did_count") ||
!db->Write("DROP INDEX files_backupid") )
{
return false;
}
if(!db->Write("DROP TABLE files_del"))
{
return false;
}
if(!db->Write("DROP TABLE files_new"))
{
return false;
}
if (!db->Write("CREATE TABLE files_db.files ("
"id INTEGER PRIMARY KEY,"
"backupid INTEGER,"
"fullpath TEXT,"
"shahash BLOB,"
"filesize INTEGER,"
"created INTEGER DEFAULT (CAST(strftime('%s','now') as INTEGER)),"
"rsize INTEGER, clientid INTEGER, incremental INTEGER, hashpath TEXT, next_entry INTEGER, prev_entry INTEGER, pointed_to INTEGER)"))
{
return false;
}
IDatabaseCursor* cur = db->Prepare("SELECT rowid, backupid, fullpath, shahash, filesize, strftime('%s', created) AS created, rsize, clientid, incremental, hashpath FROM files_bck")->Cursor();
IQuery* q_insert_file = db->Prepare("INSERT INTO files_db.files (id, backupid, fullpath, shahash, filesize, created, rsize, clientid, incremental, hashpath, next_entry, prev_entry, pointed_to) "
"VALUES (?,?,?,?,?,?,?,?,?,?,0,0,0)");
db_single_result res;
while (cur->next(res))
{
q_insert_file->Bind(watoi64(res["rowid"]));
q_insert_file->Bind(watoi(res["backupid"]));
q_insert_file->Bind(res["fullpath"]);
q_insert_file->Bind(res["shahash"].c_str(), static_cast<_u32>(res["shahash"].size()));
q_insert_file->Bind(watoi64(res["filesize"]));
q_insert_file->Bind(watoi64(res["created"]));
q_insert_file->Bind(watoi64(res["rsize"]));
q_insert_file->Bind(watoi(res["clientid"]));
q_insert_file->Bind(watoi(res["incremental"]));
q_insert_file->Bind(res["hashpath"]);
q_insert_file->Write();
q_insert_file->Reset();
}
if (cur->has_error())
{
return false;
}
if(!db->Write("DROP TABLE files_bck"))
{
return false;
}
if(!db->Write("CREATE INDEX files_db.files_backupid ON files (backupid)"))
{
return false;
}
if(!db->Write("CREATE TABLE files_incoming_stat (id INTEGER PRIMARY KEY, filesize INTEGER, clientid INTEGER, backupid INTEGER, existing_clients TEXT, direction INTEGER, incremental INTEGER)"))
{
return false;
}
return true;
}
bool upgrade36_37()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE backups ADD tgroup INTEGER");
b &= db->Write("UPDATE backups SET tgroup=0 WHERE tgroup IS NULL");
return b;
}
bool update37_38()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("CREATE TABLE log_data (id INTEGER PRIMARY KEY, logid INTEGER REFERENCES logs(id) ON DELETE CASCADE, data TEXT)");
b &= db->Write("CREATE INDEX log_data_idx ON log_data (logid)");
IQuery* q_ins=db->Prepare("INSERT INTO log_data (logid, data) VALUES (?, ?)");
db_results res;
do
{
res=db->Read("SELECT l.id AS id, l.logdata AS logdata FROM logs l WHERE NOT EXISTS (SELECT id FROM log_data WHERE logid = l.id) LIMIT 100");
for(size_t i=0;i<res.size();++i)
{
q_ins->Bind(res[i]["id"]);
q_ins->Bind(res[i]["logdata"]);
q_ins->Write();
q_ins->Reset();
}
} while (!res.empty());
b &= db->Write("UPDATE logs SET logdata = NULL");
return b;
}
bool update38_39()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("CREATE TABLE users_on_client (id INTEGER PRIMARY KEY, clientid INTEGER REFERENCES clients(id) ON DELETE CASCADE, username TEXT)");
b &= db->Write("CREATE UNIQUE INDEX users_on_client_unique ON users_on_client(clientid, username)");
b &= db->Write("CREATE TABLE tokens_on_client (id INTEGER PRIMARY KEY, clientid INTEGER REFERENCES clients(id) ON DELETE CASCADE, token TEXT)");
b &= db->Write("CREATE UNIQUE INDEX tokens_on_client_unique ON tokens_on_client(clientid, token)");
b &= db->Write("CREATE TABLE user_tokens (id INTEGER PRIMARY KEY, username TEXT, token TEXT)");
b &= db->Write("CREATE UNIQUE INDEX user_tokens_unique ON user_tokens(username, token)");
return b;
}
bool update39_40()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE logs ADD restore INTEGER");
b &= db->Write("UPDATE logs SET restore=0 WHERE restore IS NULL");
b &= db->Write("CREATE TABLE restores (id INTEGER PRIMARY KEY, clientid INTEGER REFERENCES clients(id) ON DELETE CASCADE, created DATE DEFAULT CURRENT_TIMESTAMP, finished DATE, done INTEGER, path TEXT, identity TEXT, success INTEGER)");
return b;
}
bool upgrade40_41()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE settings_db.si_users ADD pbkdf2_rounds INTEGER");
b &= db->Write("UPDATE settings_db.si_users SET pbkdf2_rounds=0");
if(crypto_fak!=NULL)
{
db_results res = db->Read("SELECT id, password_md5, salt FROM settings_db.si_users");
const size_t pbkdf2_rounds = 10000;
IQuery* q_update = db->Prepare("UPDATE settings_db.si_users SET password_md5=?, pbkdf2_rounds=? WHERE id=?");
for(size_t i=0;i<res.size();++i)
{
std::string password_md5 = strlower(crypto_fak->generatePasswordHash(hexToBytes((res[i]["password_md5"])),
(res[i]["salt"]), pbkdf2_rounds));
q_update->Bind(password_md5);
q_update->Bind(pbkdf2_rounds);
q_update->Bind(res[i]["id"]);
q_update->Write();
q_update->Reset();
}
}
return b;
}
bool upgrade41_42()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE clients ADD virtualmain TEXT");
return b;
}
bool upgrade42_43()
{
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("CREATE TABLE settings_db.access_tokens ("
"clientid INTEGER,"
"tokenhash BLOB)");
b &= db->Write("CREATE UNIQUE INDEX settings_db.access_tokens_idx ON access_tokens(tokenhash)");
return b;
}
bool upgrade43_44()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE restores ADD image INTEGER DEFAULT 0");
b &= db->Write("ALTER TABLE restores ADD letter TEXT DEFAULT ''");
return b;
}
bool upgrade44_45()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
if (!db->Read("SELECT * FROM sqlite_master WHERE name = 'files' AND type = 'table'").empty())
{
db->Write("DROP TABLE IF EXISTS files_db.files");
if (!db->Write("CREATE TABLE files_db.files ("
"id INTEGER PRIMARY KEY,"
"backupid INTEGER,"
"fullpath TEXT,"
"shahash BLOB,"
"filesize INTEGER,"
"created INTEGER DEFAULT (CAST(strftime('%s','now') as INTEGER)),"
"rsize INTEGER, clientid INTEGER, incremental INTEGER, hashpath TEXT, next_entry INTEGER, prev_entry INTEGER, pointed_to INTEGER)"))
{
return false;
}
IDatabaseCursor* cur = db->Prepare("SELECT id, backupid, fullpath, shahash, filesize, strftime('%s', created) AS created, rsize, clientid, incremental, hashpath FROM files")->Cursor();
IQuery* q_insert_file = db->Prepare("INSERT INTO files_db.files (id, backupid, fullpath, shahash, filesize, created, rsize, clientid, incremental, hashpath, next_entry, prev_entry, pointed_to) "
"VALUES (?,?,?,?,?,?,?,?,?,?,0,0,0)");
db_single_result res;
while (cur->next(res))
{
q_insert_file->Bind(watoi64(res["id"]));
q_insert_file->Bind(watoi(res["backupid"]));
q_insert_file->Bind(res["fullpath"]);
q_insert_file->Bind(res["shahash"].c_str(), static_cast<_u32>(res["shahash"].size()));
q_insert_file->Bind(watoi64(res["filesize"]));
q_insert_file->Bind(watoi64(res["created"]));
q_insert_file->Bind(watoi64(res["rsize"]));
q_insert_file->Bind(watoi(res["clientid"]));
q_insert_file->Bind(watoi(res["incremental"]));
q_insert_file->Bind(res["hashpath"]);
q_insert_file->Write();
q_insert_file->Reset();
}
if (cur->has_error())
{
return false;
}
if (!db->Write("DROP TABLE files"))
{
return false;
}
if (!db->Write("CREATE INDEX files_db.files_backupid ON files (backupid)"))
{
return false;
}
}
if (!db->Write("CREATE TABLE files_db.files_incoming_stat (id INTEGER PRIMARY KEY, filesize INTEGER, clientid INTEGER, backupid INTEGER, existing_clients TEXT, direction INTEGER, incremental INTEGER)"))
{
return false;
}
if (!db->Write("DROP TABLE files_incoming_stat"))
{
return false;
}
if (!db->Write("CREATE TABLE links_db.directory_links ("
"id INTEGER PRIMARY KEY,"
"clientid INTGER,"
"name TEXT,"
"target TEXT)"))
{
return false;
}
IDatabaseCursor* cur = db->Prepare("SELECT id, clientid, name, target FROM directory_links")->Cursor();
IQuery* q_insert_link = db->Prepare("INSERT INTO links_db.directory_links (id, clientid, name, target) "
"VALUES (?, ?, ?, ?)");
db_single_result res;
while (cur->next(res))
{
q_insert_link->Bind(res["id"]);
q_insert_link->Bind(res["clientid"]);
q_insert_link->Bind(res["name"]);
q_insert_link->Bind(res["target"]);
q_insert_link->Write();
q_insert_link->Reset();
}
if (!db->Write("CREATE INDEX links_db.directory_links_idx ON directory_links (clientid, name)"))
{
return false;
}
if (!db->Write("CREATE INDEX links_db.directory_links_target_idx ON directory_links (clientid, target)"))
{
return false;
}
if (!db->Write("CREATE TABLE link_journal_db.directory_link_journal ("
"id INTEGER PRIMARY KEY,"
"linkname TEXT,"
"linktarget TEXT)"))
{
return false;
}
if (!db->Write("DROP TABLE directory_links"))
{
return false;
}
if (!db->Write("DROP TABLE directory_link_journal"))
{
return false;
}
return true;
}
bool upgrade45_46()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("DROP TABLE user_tokens");
b &= db->Write("CREATE TABLE user_tokens (id INTEGER PRIMARY KEY, username TEXT, tgroup TEXT, clientid INTEGER DEFAULT 0, token TEXT, created DATE DEFAULT CURRENT_TIMESTAMP)");
b &= db->Write("CREATE UNIQUE INDEX user_tokens_unique ON user_tokens(username, clientid, token, tgroup)");
return b;
}
bool upgrade46_47()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE clients ADD last_filebackup_issues INTEGER DEFAULT 0");
b &= db->Write("ALTER TABLE clients ADD os_simple TEXT");
b &= db->Write("ALTER TABLE clients ADD os_version_str TEXT");
b &= db->Write("ALTER TABLE clients ADD client_version_str TEXT");
return b;
}
bool upgrade47_48()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE clients ADD groupid INTEGER DEFAULT 0");
b &= db->Write("UPDATE clients SET groupid=0 WHERE groupid IS NULL");
b &= db->Write("CREATE TABLE settings_db.si_client_groups ("
"id INTEGER PRIMARY KEY,"
"name TEXT)");
return b;
}
bool upgrade48_49()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE backups ADD synctime INTEGER");
b &= db->Write("ALTER TABLE backup_images ADD synctime INTEGER");
return b;
}
bool upgrade49_50()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("UPDATE settings_db.settings SET value='0' WHERE value='-1' "
"AND (key='local_speed' OR key='internet_speed' OR key='global_local_speed' OR key='global_internet_speed')");
return b;
}
bool upgrade50_51()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE backup_images ADD archived INTEGER");
b &= db->Write("UPDATE backup_images SET archived=0 WHERE archived IS NULL");
b &= db->Write("ALTER TABLE backup_images ADD archive_timeout INTEGER");
b &= db->Write("ALTER TABLE backup_images ADD mounttime INTEGER");
b &= db->Write("UPDATE backup_images SET mounttime=0 WHERE mounttime IS NULL");
b &= db->Write("UPDATE settings_db.settings SET value='0' WHERE value='-1' "
"AND (key='local_speed' OR key='internet_speed' OR key='global_local_speed' OR key='global_internet_speed')");
ServerSettings::updateAll();
return b;
}
bool upgrade51_52()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE backups ADD delete_pending INTEGER");
b &= db->Write("ALTER TABLE backup_images ADD delete_pending INTEGER");
return b;
}
bool upgrade52_53()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE settings_db.automatic_archival ADD letters TEXT");
b &= db->Write("UPDATE settings_db.automatic_archival SET letters='' WHERE letters IS NULL");
b &= db->Write("UPDATE settings_db.automatic_archival SET letters='ALL' WHERE backup_types=4 OR backup_types=8 OR backup_types=12");
return b;
}
bool upgrade53_54()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("INSERT INTO settings_db.settings (key, value, clientid) VALUES ('restore_authkey','"+ServerSettings::generateRandomAuthKey()+"', 0)");
return b;
}
bool upgrade54_55()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE clients ADD file_ok INTEGER");
b &= db->Write("ALTER TABLE clients ADD image_ok INTEGER");
b &= db->Write("ALTER TABLE clients ADD alerts_state BLOB");
b &= db->Write("ALTER TABLE clients ADD alerts_next_check INTEGER");
b &= db->Write("ALTER TABLE clients ADD created INTEGER");
b &= db->Write("UPDATE clients SET created=0");
b &= db->Write("UPDATE clients SET file_ok=0, image_ok=0");
b &= db->Write("CREATE TABLE alert_scripts (id INTEGER PRIMARY KEY, "
"name TEXT, script TEXT)");
b &= db->Write("CREATE TABLE alert_script_params(id INTEGER PRIMARY KEY, "
"script_id INTEGER REFERENCES alert_scripts(id) ON DELETE CASCADE, "
"idx INTEGER, name TEXT, label TEXT, default_value TEXT, has_translation INTEGER DEFAULT 0, type TEXT)");
IQuery *q = db->Prepare("INSERT INTO alert_scripts (id, name, script) VALUES (?, ?, '')");
if (q != NULL)
{
q->Bind(1);
q->Bind("Default");
b &= q->Write();
}
else
{
b = false;
}
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (1, 0, 'alert_file_mult', 'alert_file_mult', '3', 1, 'num')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (1, 1, 'alert_image_mult', 'alert_image_mult', '3', 1, 'num')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (1, 2, 'alert_emails', 'alert_emails', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (1, 3, 'alert_important', 'alert_important', '0', 1, 'bool')");
b &= db->Write("CREATE TABLE mail_queue (id INTEGER PRIMARY KEY, send_to TEXT, subject TEXT, message TEXT, next_try INTEGER, retry_count INTEGER DEFAULT 0)");
return b;
}
bool upgrade55_56()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (1, 4, 'alert_mail_ok', 'alert_mail_ok', '1', 1, 'bool')");
return b;
}
bool upgrade56_57()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("CREATE TABLE moved_clients (id INTEGER PRIMARY KEY, "
"from_name TEXT, "
"to_name TEXT)");
b &= db->Write("CREATE INDEX moved_clients_from_idx ON moved_clients(from_name)");
b &= db->Write("ALTER TABLE clients ADD uid TEXT");
b &= db->Write("CREATE TABLE mounted_backup_images (id INTEGER PRIMARY KEY, "
"backupid INTEGER REFERENCES backup_images(id) ON DELETE CASCADE, "
"partition INTEGER,"
"mounttime INTEGER)");
return b;
}
const int64 script_id_default = 1;
const int64 script_id_pulseway = 100000;
bool upgrade57_58()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("ALTER TABLE alert_scripts ADD global_state BLOB");
int64 scriptid = script_id_pulseway;
b &= db->Write("INSERT INTO alert_scripts (id, name, script) VALUES (" + convert(scriptid) + ", 'Pulseway API', '')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 0, 'username', 'pulseway_username', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 1, 'password', 'pulseway_password', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 2, 'instance_id', 'pulseway_instance_id', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 3, 'instance_name', 'pulseway_instance_name', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 4, 'instance_group', 'pulseway_instance_group', 'Default', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 5, 'instance_description', 'pulseway_instance_description', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 6, 'refresh_interval_minutes', 'pulseway_refresh_interval_minutes', '15', 1, 'num')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 7, 'instance_notify_when_offline', 'pulseway_instance_notify_when_offline', '1', 1, 'bool')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 8, 'api_url', 'pulseway_api_url', 'https://api.pulseway.com/v2', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 9, 'alert_file_mult', 'alert_file_mult', '3', 1, 'num')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 10, 'alert_image_mult', 'alert_image_mult', '3', 1, 'num')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 11, 'alert_emails', 'alert_emails', '', 1, 'str')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 12, 'alert_important', 'alert_important', '0', 1, 'bool')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 13, 'priority', 'pulseway_priority', 'normal|low|elevated|critical', 1, 'choice')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(scriptid) + ", 14, 'alert_ok', 'pulseway_alert_ok', '1', 1, 'bool')");
return b;
}
bool upgrade58_59()
{
IDatabase *db = Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
bool b = true;
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(script_id_pulseway) + ", 15, 'alert_nag_interval', 'pulseway_alert_nag_interval', '0|h', 1, 'interval')");
b &= db->Write("INSERT INTO alert_script_params (script_id, idx, name, label, default_value, has_translation, type) VALUES (" + convert(script_id_default) + ", 5, 'alert_nag_interval', 'alert_nag_interval', '0|h', 1, 'interval')");
return b;
}
void upgrade(void)
{
Server->destroyAllDatabases();
IDatabase *db=Server->getDatabase(Server->getThreadID(), URBACKUPDB_SERVER);
IQuery *qp=db->Prepare("SELECT tvalue FROM misc WHERE tkey='db_version'");
if(qp==NULL)
{
Server->Log("Importing data...");
db->Import("urbackup/backup_server.dat");
qp=db->Prepare("SELECT tvalue FROM misc WHERE tkey='db_version'");
}
if(qp==NULL)
{
return;
}
db_results res_v=qp->Read();
if(res_v.empty())
return;
int ver=watoi(res_v[0]["tvalue"]);
int old_v;
int max_v=59;
{
IScopedLock lock(startup_status.mutex);
startup_status.target_db_version=max_v;
startup_status.curr_db_version=ver;
}
bool do_upgrade=false;
if(ver<max_v)
{
do_upgrade=true;
Server->Log("Upgrading...", LL_WARNING);
if (!attach_other_dbs(db))
{
Server->Log("Attaching other databases failed", LL_ERROR);
return;
}
}
db_results cache_res;
if(db->getEngineName()=="sqlite"
&& ver>15)
{
cache_res=db->Read("PRAGMA cache_size");
ServerSettings server_settings(db);
db->Write("PRAGMA cache_size = -"+convert(server_settings.getSettings()->update_stats_cachesize));
}
IQuery *q_update=db->Prepare("UPDATE misc SET tvalue=? WHERE tkey='db_version'");
do
{
if(ver<max_v)
{
Server->Log("Upgrading database to version "+convert(ver+1), LL_WARNING);
}
if(ver>max_v)
{
Server->Log("Current UrBackup database version is "+convert(ver)+". This UrBackup"
" server version only supports databases up to version "+convert(max_v)+"."
" You need a newer UrBackup server version to work with this database.", LL_ERROR);
exit(4);
}
db->BeginWriteTransaction();
old_v=ver;
bool has_error=false;
switch(ver)
{
case 1:
upgrade1_2();
++ver;
break;
case 2:
upgrade2_3();
++ver;
break;
case 3:
upgrade3_4();
++ver;
break;
case 4:
upgrade4_5();
++ver;
break;
case 5:
upgrade5_6();
++ver;
break;
case 6:
upgrade6_7();
++ver;
break;
case 7:
upgrade7_8();
++ver;
break;
case 8:
upgrade8_9();
++ver;
break;
case 9:
upgrade9_10();
++ver;
break;
case 10:
upgrade10_11();
++ver;
break;
case 11:
upgrade11_12();
++ver;
break;
case 12:
upgrade12_13();
++ver;
break;
case 13:
upgrade13_14();
++ver;
break;
case 14:
upgrade14_15();
++ver;
break;
case 15:
upgrade15_16();
++ver;
break;
case 16:
upgrade16_17();
++ver;
break;
case 17:
upgrade17_18();
++ver;
break;
case 18:
upgrade18_19();
++ver;
break;
case 19:
upgrade19_20();
++ver;
break;
case 20:
upgrade20_21();
++ver;
break;
case 21:
upgrade21_22();
++ver;
break;
case 22:
upgrade22_23();
++ver;
break;
case 23:
upgrade23_24();
++ver;
break;
case 24:
upgrade24_25();
++ver;
break;
case 25:
upgrade25_26();
++ver;
break;
case 26:
upgrade26_27();
++ver;
break;
case 27:
upgrade27_28();
++ver;
break;
case 28:
upgrade28_29();
++ver;
break;
case 29:
upgrade29_30();
++ver;
break;
case 30:
upgrade30_31();
++ver;
break;
case 31:
upgrade31_32();
++ver;
break;
case 32:
upgrade32_33();
++ver;
break;
case 33:
upgrade33_34();
++ver;
break;
case 34:
upgrade34_35();
++ver;
break;
case 35:
if(!upgrade35_36())
{
has_error=true;
}
++ver;
break;
case 36:
if(!upgrade36_37())
{
has_error=true;
}
++ver;
break;
case 37:
if(!update37_38())
{
has_error=true;
}
++ver;
break;
case 38:
if(!update38_39())
{
has_error=true;
}
++ver;
break;
case 39:
if(!update39_40())
{
has_error=true;
}
++ver;
break;
case 40:
if(!upgrade40_41())
{
has_error=true;
}
++ver;
break;
case 41:
if(!upgrade41_42())
{
has_error=true;
}
++ver;
break;
case 42:
if(!upgrade42_43())
{
has_error=true;
}
++ver;
break;
case 43:
if (!upgrade43_44())
{
has_error = true;
}
++ver;
break;
case 44:
if (!upgrade44_45())
{
has_error = true;
}
++ver;
break;
case 45:
if (!upgrade45_46())
{
has_error = true;
}
++ver;
case 46:
if (!upgrade46_47())
{
has_error = true;
}
++ver;
break;
case 47:
if (!upgrade47_48())
{
has_error = true;
}
++ver;
break;
case 48:
if (!upgrade48_49())
{
has_error = true;
}
++ver;
break;
case 49:
if (!upgrade49_50())
{
has_error = true;
}
++ver;
break;
case 50:
if (!upgrade50_51())
{
has_error = true;
}
++ver;
break;
case 51:
if (!upgrade51_52())
{
has_error = true;
}
++ver;
break;
case 52:
if (!upgrade52_53())
{
has_error = true;
}
++ver;
break;
case 53:
if (!upgrade53_54())
{
has_error = true;
}
++ver;
break;
case 54:
if (!upgrade54_55())
{
has_error = true;
}
++ver;
break;
case 55:
if (!upgrade55_56())
{
has_error = true;
}
++ver;
break;
case 56:
if (!upgrade56_57())
{
has_error = true;
}
++ver;
break;
case 57:
if (!upgrade57_58())
{
has_error = true;
}
++ver;
break;
case 58:
if (!upgrade58_59())
{
has_error = true;
}
++ver;
break;
default:
break;
}
if(has_error ||
(Server->getFailBits() & IServer::FAIL_DATABASE_CORRUPTED) ||
(Server->getFailBits() & IServer::FAIL_DATABASE_IOERR) ||
(Server->getFailBits() & IServer::FAIL_DATABASE_FULL) )
{
db->Write("ROLLBACK");
Server->Log("Upgrading database failed. Shutting down server.", LL_ERROR);
exit(5);
}
if(ver!=old_v)
{
q_update->Bind(ver);
q_update->Write();
q_update->Reset();
if(ver==36)
{
if(db->EndTransaction())
{
db->Write("PRAGMA page_size = 4096");
db->Write("VACUUM");
db->BeginWriteTransaction();
}
else
{
Server->Log("Upgrading database failed. Ending transaction failed. Shutting down server.", LL_ERROR);
exit(5);
}
}
{
IScopedLock lock(startup_status.mutex);
startup_status.curr_db_version=ver;
}
}
db->EndTransaction();
}
while(old_v<ver);
if(do_upgrade)
{
detach_other_dbs(db);
Server->Log("Done.", LL_WARNING);
}
if(!cache_res.empty())
{
db->Write("PRAGMA cache_size = "+cache_res[0]["cache_size"]);
db->freeMemory();
}
Server->clearDatabases(Server->getThreadID());
}
Reference in New Issue View Git Blame Copy Permalink