void Database_HebrewLexicon::create ()
{
filter_url_unlink (database_sqlite_file (filename ()));
SqliteDatabase sql = SqliteDatabase (filename ());
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS aug (aug text, target text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS bdb (id text, definition text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS map (id text, bdb text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS pos (code text, name text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS strong (strong text, definition text);");
sql.execute ();
}
void Database_MorphGnt::create ()
{
filter_url_unlink (database_sqlite_file (filename ()));
SqliteDatabase sql = SqliteDatabase (filename ());
sql.clear ();
sql.add ("CREATE TABLE morphgnt (book int, chapter int, verse int, pos int, parsing int, word int, lemma int);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS pos (pos text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS parsing (parsing text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS word (word text);");
sql.execute ();
sql.clear ();
sql.add ("CREATE TABLE IF NOT EXISTS lemma (lemma text);");
sql.execute ();
}
// Clears all journal entries.
void Database_Logs::clear ()
{
string directory = folder ();
vector <string> files = filter_url_scandir (directory);
for (auto file : files) {
filter_url_unlink (filter_url_create_path (directory, file));
}
log ("The journal was cleared");
}
void Database_State::create ()
{
bool healthy_database = database_sqlite_healthy (name ());
if (!healthy_database) {
filter_url_unlink (database_sqlite_file (name ()));
}
sqlite3 * db = connect ();
string sql;
// On Android, this pragma prevents the following error: VACUUM; Unable to open database file.
sql = "PRAGMA temp_store = MEMORY;";
database_sqlite_exec (db, sql);
sql =
"CREATE TABLE IF NOT EXISTS notes ("
" first integer,"
" last integer,"
" value text"
");";
database_sqlite_exec (db, sql);
sql = "DELETE FROM notes;";
database_sqlite_exec (db, sql);
// Here something weird was going on when doing a VACUUM at this stage.
// On Android, it always would say this: VACUUM; Unable to open database file.
// Testing on the existence of the database file, right before the VACUUM operation, showed that the database file did exist. The question is then: If the file exists, why does it fail to open it?
// It also was tried to delay with 100 milliseconds before doing the VACUUM. But this made no difference. It would still give the error.
// It also was tried to close the connection to the database, then open it again. This made no difference either.
// It now does not VACUUM a newly created database, but only when it was created.
// Later on, the PRAGMA as above was used to solve the issue.
sql = "VACUUM;";
database_sqlite_exec (db, sql);
sql =
"CREATE TABLE IF NOT EXISTS export ("
" bible text,"
" book integer,"
" format integer"
");";
database_sqlite_exec (db, sql);
sql =
"CREATE TABLE IF NOT EXISTS exported ("
" bible text,"
" book integer,"
" state boolean"
");";
database_sqlite_exec (db, sql);
database_sqlite_disconnect (db);
}
void search_logic_delete_chapter (string bible, int book, int chapter)
{
string fragment = search_logic_chapter_file (bible, book, chapter);
fragment = filter_url_basename (fragment);
vector <string> files = filter_url_scandir (search_logic_index_folder ());
for (auto & file : files) {
if (file.find (fragment) == 0) {
string path = filter_url_create_path (search_logic_index_folder (), file);
filter_url_unlink (path);
}
}
}
// Compresses a $folder into gzipped tar format.
// Returns the path to the compressed archive it created.
string filter_archive_tar_gzip_folder (string folder)
{
string tarball = filter_url_tempfile () + ".tar.gz";
folder = filter_url_escape_shell_argument (folder);
string logfile = filter_url_tempfile () + ".log";
string command = "cd " + folder + " && tar -czf " + tarball + " . > " + logfile + " 2>&1";
int return_var = system (command.c_str());
if (return_var != 0) {
filter_url_unlink (tarball);
tarball.clear();
string errors = filter_url_file_get_contents (logfile);
Database_Logs::log (errors);
}
return tarball;
}
void Database_Login::optimize ()
{
if (!healthy ()) {
// (Re)create damaged or non-existing database.
filter_url_unlink (database_sqlite_file (database ()));
create ();
}
// Vacuum it.
SqliteDatabase sql (database ());
// On Android, this pragma prevents the following error: VACUUM; Unable to open database file.
sql.add ("PRAGMA temp_store = MEMORY;");
sql.execute ();
sql.clear ();
sql.add ("VACUUM;");
sql.execute ();
}
void tmp_tmp ()
{
Database_Logs::log ("Removing expired temporal files", Filter_Roles::admin ());
int expired = filter_date_seconds_since_epoch () - (3600 * 24 * 3);
string directory = filter_url_create_root_path ("tmp");
vector <string> names = filter_url_scandir (directory);
for (auto & name : names) {
if (name.find ("tmp.") == 0) continue;
string filename = filter_url_create_path (directory, name);
int mtime = filter_url_filemtime (filename);
if (mtime < expired) {
filter_url_rmdir (filename);
filter_url_unlink (filename);
}
}
}
// Compresses a $folder into zip format.
// Returns the path to the compressed archive it created.
string filter_archive_zip_folder (string folder)
{
if (!file_or_dir_exists (folder)) return "";
string zippedfile = filter_url_tempfile () + ".zip";
string logfile = filter_url_tempfile () + ".log";
folder = filter_url_escape_shell_argument (folder);
string command = "cd " + folder + " && zip -r " + zippedfile + " * > " + logfile + " 2>&1";
int return_var = system (command.c_str());
if (return_var != 0) {
filter_url_unlink (zippedfile);
zippedfile.clear();
string errors = filter_url_file_get_contents (logfile);
Database_Logs::log (errors);
}
return zippedfile;
}
void Database_NoteAssignment::remove (string user)
{
filter_url_unlink (path (user));
}
void Database_Logs::rotate ()
{
// Remove the database that was used in older versions of Bibledit.
// Since February 2016 Bibledit no longer uses a database for storing the journal.
// Reasons that a database is no longer used:
// 1. Simpler system.
// 2. Android has VACUUM errors due to a locked database.
string old_database_file = database_sqlite_file ("logs2");
if (file_exists (old_database_file)) {
filter_url_unlink (old_database_file);
}
// Use a mechanism that handles huge amounts of entries.
// The PHP function scandir choked on this or took a very long time.
// The PHP functions opendir / readdir / closedir handled it better.
// But now, in C++, with the new journal mechanism, this is no longer relevant.
string directory = folder ();
vector <string> files = filter_url_scandir (directory);
// Timestamp for removing older records, depending on whether it's a tiny journal.
#ifdef HAVE_TINYJOURNAL
int oldtimestamp = filter_date_seconds_since_epoch () - (14400);
#else
int oldtimestamp = filter_date_seconds_since_epoch () - (6 * 86400);
#endif
// Limit the available the journal entrie count in the filesystem.
// This speeds up subsequent reading of the Journal by the users.
// In previous versions of Bibledit, there were certain conditions
// that led to an infinite loop, as had been noticed at times,
// and this quickly exhausted the available inodes on the filesystem.
#ifdef HAVE_TINYJOURNAL
int limitfilecount = files.size () - 200;
#else
int limitfilecount = files.size () - 2000;
#endif
bool filtered_entries = false;
for (unsigned int i = 0; i < files.size(); i++) {
string path = filter_url_create_path (directory, files [i]);
// Limit the number of journal entries.
if ((int)i < limitfilecount) {
filter_url_unlink (path);
continue;
}
// Remove expired entries.
int timestamp = convert_to_int (files [i].substr (0, 10));
if (timestamp < oldtimestamp) {
filter_url_unlink (path);
continue;
}
// Filtering of certain entries.
string entry = filter_url_file_get_contents (path);
if (journal_logic_filter_entry (entry)) {
filtered_entries = true;
filter_url_unlink (path);
continue;
}
}
if (filtered_entries) {
log (journal_logic_filtered_message ());
}
}
void Fonts_Logic::erase (string font)
{
string path = filter_url_create_path (folder (), font);
filter_url_unlink (path);
}
int main (int argc, char **argv)
{
if (argc) {};
if (argv[0]) {};
// Ctrl-C initiates a clean shutdown sequence, so there's no memory leak.
signal (SIGINT, sigint_handler);
#ifdef HAVE_EXECINFO
// Handler for logging segmentation fault.
signal (SIGSEGV, sigsegv_handler);
#endif
// Get the executable path and base the document root on it.
string webroot;
{
// The following works on Linux but not on Mac OS X:
char *linkname = (char *) malloc (256);
memset (linkname, 0, 256); // valgrind uninitialized value(s)
ssize_t r = readlink ("/proc/self/exe", linkname, 256);
if (r) {};
webroot = filter_url_dirname (linkname);
free (linkname);
}
{
#ifdef HAVE_LIBPROC
// The following works on Linux plus on Mac OS X:
int ret;
pid_t pid;
char pathbuf [2048];
pid = getpid ();
ret = proc_pidpath (pid, pathbuf, sizeof (pathbuf));
if (ret > 0 ) {
webroot = filter_url_dirname (pathbuf);
}
#endif
}
bibledit_initialize_library (webroot.c_str(), webroot.c_str());
// Start the Bibledit library.
bibledit_start_library ();
bibledit_log ("The server started");
cout << "Listening on http://localhost:" << config_logic_http_network_port () <<
" and https://localhost:" << config_logic_https_network_port () << endl;
cout << "Press Ctrl-C to quit" << endl;
// Log possible backtrace from a previous crash.
string backtrace = filter_url_file_get_contents (backtrace_path ());
filter_url_unlink (backtrace_path ());
if (!backtrace.empty ()) {
Database_Logs::log ("Backtrace of the last segmentation fault:");
vector <string> lines = filter_string_explode (backtrace, '\n');
for (auto & line : lines) {
Database_Logs::log (line);
}
}
// Bibledit Cloud should restart itself at midnight.
// This is to be sure that any memory leaks don't accumulate too much
// in case Bibledit Cloud runs for months and years.
bibledit_set_quit_at_midnight ();
// Keep running till Bibledit stops or gets interrupted.
while (bibledit_is_running ()) { };
bibledit_shutdown_library ();
return EXIT_SUCCESS;
}
