void notes_convert_database_to_plain_files ()
{
// Bail out if there's no database to convert.
ustring database_filename = gw_build_filename(Directories->get_notes(), "notes.sql2");
if (!g_file_test(database_filename.c_str(), G_FILE_TEST_IS_REGULAR)) {
return;
}
// Progress window.
ProgressWindow progresswindow (_("Converting project notes"), false);
// Access the database.
sqlite3 *db;
int rc;
char *error = NULL;
try {
rc = sqlite3_open(database_filename.c_str(), &db);
if (rc) throw runtime_error(sqlite3_errmsg(db));
sqlite3_busy_timeout(db, 1000);
{
// Read how many notes there are.
SqliteReader reader(0);
char *sql;
sql = g_strdup_printf("select count(*) from notes;");
rc = sqlite3_exec(db, sql, reader.callback, &reader, &error);
g_free(sql);
if (rc != SQLITE_OK) throw runtime_error(error);
if (!reader.ustring0.empty()) {
progresswindow.set_iterate (0, 1, convert_to_int (reader.ustring0[0]));
}
}
{
SqliteReader reader(0);
rc = sqlite3_exec(db, "select id, ref_osis, project, category, note, created, modified, user, logbook from notes;", reader.callback, &reader, &error);
if (rc != SQLITE_OK) throw runtime_error(error);
for (unsigned int i = 0; i < reader.ustring0.size(); i++) {
progresswindow.iterate ();
notes_store_one_in_file(convert_to_int (reader.ustring0[i]), // ID.
reader.ustring4[i], // Note.
reader.ustring2[i], // Project.
reader.ustring1[i], // References.
reader.ustring3[i], // Category.
convert_to_int (reader.ustring5[i]), // Date created.
reader.ustring7[i], // User.
convert_to_int (reader.ustring6[i]), // Date modified.
reader.ustring8[i]); // Logbook.
}
}
// Delete the notes database that was converted.
unix_unlink (database_filename.c_str());
}
catch(exception & ex) {
gw_critical(ex.what());
}
sqlite3_close(db);
}
void git_upgrade ()
// Upgrades the git system.
{
// Go through the projects that have their git repository enabled.
extern Settings * settings;
vector <ustring> projects = projects_get_all ();
for (unsigned int i = 0; i < projects.size(); i++) {
ProjectConfiguration * projectconfig = settings->projectconfig (projects[i]);
ustring git_directory = gw_build_filename (project_data_directory_project (projects[i]), ".git");
if (projectconfig->git_use_remote_repository_get()) {
// At times there's a stale index.lock file that prevents any collaboration.
// This is to be removed.
ustring index_lock = gw_build_filename (git_directory, "index.lock");
if (g_file_test (index_lock.c_str(), G_FILE_TEST_IS_REGULAR)) {
gw_message (_("Cleaning out index lock ") + index_lock);
unix_unlink (index_lock.c_str());
}
// Get the data directory for the project
ustring datadirectory = tiny_project_data_directory_project(projects[i]);
// On most machines git can determine the user's name from the system services.
// On the XO machine, it can't. It is set here manually.
// On more recent versions of git, like version 1.8.3 and younger,
// although git may determine the user's name from the system,
// it still requires it to be set manually.
ustring command;
command = "git config user.email \"";
command.append(g_get_user_name());
command.append("@");
command.append(g_get_host_name());
command.append("\"");
maintenance_register_shell_command (datadirectory, command);
command = "git config user.name \"";
command.append(g_get_real_name());
command.append("\"");
maintenance_register_shell_command (datadirectory, command);
// (Re)initialize the repository. This can be done repeatedly without harm.
// Note that this is done on shutdown.
maintenance_register_shell_command (datadirectory, "git init");
} else {
if (g_file_test (git_directory.c_str(), G_FILE_TEST_IS_DIR)) {
gw_message (_("Cleaning out folder ") + git_directory);
ProgressWindow progresswindow (_("Tidying up project ") + projects[i], false);
progresswindow.set_fraction (0.5);
unix_rmdir (git_directory);
}
}
}
}
void notes_create_index ()
// This creates an index for the notes stored in plain files.
{
ProgressWindow progresswindow (_("Creating notes index"), false);
// Remove any old index.
unix_unlink (notes_index_filename ().c_str());
// Create index database.
sqlite3 *db;
int rc;
char *error = NULL;
try {
// Connect to the index database.
rc = sqlite3_open(notes_index_filename ().c_str(), &db);
if (rc)
throw runtime_error(sqlite3_errmsg(db));
sqlite3_busy_timeout(db, 1000);
// Create the notes table.
char *sql;
sql = g_strdup_printf("create table notes (id integer, reference text, project text, category text, casefolded text, created integer, modified integer);");
rc = sqlite3_exec(db, sql, NULL, NULL, &error);
g_free(sql);
// Fast writing.
sqlite3_exec(db, "PRAGMA synchronous=OFF;", NULL, NULL, NULL);
// Create an index for all the note files. The index will speed up note selection.
ReadFiles note_files (notes_shared_storage_folder (), "", "");
progresswindow.set_iterate (0, 1, note_files.files.size());
for (unsigned int i = 0; i < note_files.files.size(); i++) {
progresswindow.iterate ();
notes_store_index_entry (db, convert_to_int (note_files.files[i]));
}
}
catch(exception & ex) {
gw_critical(ex.what());
unix_unlink (notes_index_filename ().c_str());
}
// Close connection.
sqlite3_close(db);
}
void RemoteRepositoryAssistant::on_button_clone ()
{
// Progress.
ProgressWindow progresswindow (_("Cloning repository"), false);
progresswindow.set_fraction (0.5);
// Clear out persistent clone directory.
repository_unclone();
// Create temporal clone directory.
ustring temporal_clone_directory = git_testing_directory ("tempclone");
unix_rmdir(temporal_clone_directory);
gw_mkdir_with_parents(temporal_clone_directory);
// Clone the remote repository
GwSpawn spawn("git");
spawn.workingdirectory(temporal_clone_directory);
spawn.arg ("clone");
spawn.arg(repository_url_get());
spawn.run();
if (spawn.exitstatus == 0) {
// Move the cloned repository into the persistent clone directory.
ReadDirectories rd (temporal_clone_directory, "", "");
if (!rd.directories.empty()) {
ustring subdirectory = rd.directories[0];
subdirectory = gw_build_filename (temporal_clone_directory, subdirectory);
unix_mv (subdirectory, persistent_clone_directory);
}
unix_rmdir(temporal_clone_directory);
} else {
// Clone failed, clear out any remains.
repository_unclone();
}
// Update structures.
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_clone, repository_was_cloned());
if (repository_was_cloned()) {
gtk_label_set_text (GTK_LABEL (label_clone), _("The data has been cloned, you can go forward"));
previously_cloned_url = repository_url_get();
} else {
gtk_label_set_text (GTK_LABEL (label_clone), _("Cloning the data failed, please try again"));
repository_unclone();
}
}
// handle messages related to the progress window
LRESULT CALLBACK ProgressWindow::WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
static POINT moveMouseOffset; /* mouse offset relative to window, used for snapping */
static RECT rect; /* for general use */
ProgressWindow* win = (ProgressWindow*) Window::GetWindowObject(hwnd);
switch (message) { // handle the messages
case WM_TIMER:
if (win->autoIncrement)
{
win->increment();
}
break;
case WM_USER_START:
win->message_start((int)wParam,(bool)lParam);
break;
case WM_USER_STOP:
win->message_end();
break;
case WM_USER_RESET:
win->message_reset();
break;
case WM_USER_INCREMENT:
if (wParam==0)
win->message_increment();
else
win->message_increment(wParam);
break;
}
// call the next procedure in the chain
return CallWindowProc(win->prevProc, hwnd, message, wParam, lParam);
}
void import_bibleworks_text_file (const ustring& file, const ustring& bible, vector <ustring>& messages)
// Imports a bibleworks text file.
{
// Read the file.
ReadText rt (file, true, false);
// If there's nothing to import, bail out.
if (rt.lines.empty()) {
messages.push_back ("The file is empty");
}
// Divide the input into separate bits for each book.
vector <VectorUstring> bookdata;
if (messages.empty()) {
try {
ustring previousbook;
vector < ustring > booklines;
de_byte_order_mark (rt.lines[0]);
for (unsigned int i = 0; i < rt.lines.size(); i++) {
ustring currentbook = rt.lines[i].substr(0, 3);
if (i == 0) {
previousbook = currentbook;
}
if (currentbook != previousbook) {
bookdata.push_back (booklines);
booklines.clear();
previousbook = currentbook;
}
booklines.push_back(rt.lines[i]);
}
bookdata.push_back (booklines);
}
catch(exception & ex) {
messages.push_back(ex.what());
}
}
// Import each book.
if (messages.empty ()) {
ProgressWindow progresswindow ("Importing", false);
progresswindow.set_iterate (0, 1, bookdata.size());
for (unsigned int i = 0; i < bookdata.size(); i++) {
progresswindow.iterate ();
try {
// Input and output data.
vector <ustring> rawlines = bookdata[i];
vector <ustring> usfmlines;
// Get the name of the book.
unsigned int book_id = books_bibleworks_to_id(rawlines[0].substr(0, 3));
if (book_id == 0) {
messages.push_back ("Unknown book: " + rawlines[0]);
return;
}
// Store USFM id.
ustring usfmid = books_id_to_paratext (book_id);
usfmlines.push_back("\\id " + usfmid);
// Convert the BibleWorks lines to USFM code.
ustring previouschapter = "0";
for (unsigned int i = 0; i < rawlines.size(); i++) {
// Convert chapter information.
ustring line = rawlines[i];
line.erase(0, 4);
ustring currentchapter = number_in_string(line);
line.erase(0, currentchapter.length() + 1);
if (currentchapter != previouschapter) {
usfmlines.push_back("\\c " + currentchapter);
usfmlines.push_back("\\p");
previouschapter = currentchapter;
}
// Convert verse data.
usfmlines.push_back("\\v " + line);
}
// Store into the Bible.
CategorizeChapterVerse ccv(usfmlines);
project_store_book(bible, book_id, ccv);
}
catch(exception & ex) {
messages.push_back(ex.what());
}
}
}
}
void kjv_import_sword (const ustring& textfile, const ustring& database)
{
// Show the progress. KJV has 31102 verses.
ProgressWindow progresswindow (_("Importing King James Bible"), false);
progresswindow.set_iterate (0, 1, 31102);
gchar * contents;
g_file_get_contents(textfile.c_str(), &contents, NULL, NULL);
if (!contents)
return;
// Create the database, put it in fast mode.
unix_unlink (database.c_str());
sqlite3 *db;
sqlite3_open(database.c_str(), &db);
sqlite3_exec(db, "create table kjv (book integer, chapter integer, verse integer, item integer, fragment text, lemma text);", NULL, NULL, NULL);
sqlite3_exec(db, "PRAGMA synchronous=OFF;", NULL, NULL, NULL);
// Parse input.
xmlParserInputBufferPtr inputbuffer;
inputbuffer = xmlParserInputBufferCreateMem(contents, strlen (contents), XML_CHAR_ENCODING_NONE);
xmlTextReaderPtr reader = xmlNewTextReader(inputbuffer, NULL);
if (reader) {
bool within_relevant_element = false;
Reference reference (0, 0, "0");
unsigned int item_number = 0;
ustring textfragment;
ustring lemmata;
while ((xmlTextReaderRead(reader) == 1)) {
switch (xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT:
{
xmlChar *element_name = xmlTextReaderName(reader);
// Deal with a verse element.
if (!xmlStrcmp(element_name, BAD_CAST "verse")) {
progresswindow.iterate();
char *attribute;
attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "osisID");
if (attribute) {
Parse parse (attribute, false, ".");
if (parse.words.size() == 3) {
reference.assign(books_osis_to_id (parse.words[0]), // book
convert_to_int (parse.words[1]), // chapter
parse.words[2]); // verse
} else {
gw_critical (attribute);
}
free(attribute);
}
item_number = 0;
}
// Deal with a w element.
if (!xmlStrcmp(element_name, BAD_CAST "w")) {
within_relevant_element = true;
item_number++;
textfragment.clear();
lemmata.clear();
char *attribute;
attribute = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "lemma");
if (attribute) {
lemmata = attribute;
free(attribute);
}
}
break;
}
case XML_READER_TYPE_TEXT:
{
if (within_relevant_element) {
xmlChar *text = xmlTextReaderValue(reader);
if (text) {
textfragment = (const char *)text;
xmlFree(text);
textfragment = textfragment.casefold();
}
}
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
xmlChar *element_name = xmlTextReaderName(reader);
if (!xmlStrcmp(element_name, BAD_CAST "w")) {
replace_text (lemmata, "strong:", "");
char *sql;
sql = g_strdup_printf("insert into kjv values (%d, %d, %d, %d, '%s', '%s');",
reference.book_get(), reference.chapter_get(), convert_to_int (reference.verse_get()),
item_number,
double_apostrophy (textfragment).c_str(), lemmata.c_str());
sqlite3_exec(db, sql, NULL, NULL, NULL);
g_free(sql);
within_relevant_element = false;
}
break;
}
}
}
}
if (reader)
xmlFreeTextReader(reader);
if (inputbuffer)
xmlFreeParserInputBuffer(inputbuffer);
// Close database.
sqlite3_close(db);
// Free xml data.
g_free(contents);
}
bool Download::httpSendReqEx(HINTERNET hConnect, const string &dest,
const vector< pair<string, string> > &headers,
const string &upFile, const string &outFile, ProgressWindow &pw) const {
INTERNET_BUFFERS BufferIn;
memset(&BufferIn, 0, sizeof(BufferIn));
BufferIn.dwStructSize = sizeof( INTERNET_BUFFERS );
HINTERNET hRequest = HttpOpenRequest (hConnect, "POST", dest.c_str(), NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
DWORD dwBytesRead = 0;
DWORD dwBytesWritten = 0;
BYTE pBuffer[4*1024]; // Read from file in 4K chunks
string hdr;
for (size_t k = 0; k<headers.size(); k++) {
if (!trim(headers[k].second).empty()) {
hdr += headers[k].first + ": " + headers[k].second + "\r\n";
}
}
int retry = 5;
while (retry>0) {
HANDLE hFile = CreateFile(upFile.c_str(), GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == HANDLE(-1))
return false;
BufferIn.dwBufferTotal = GetFileSize (hFile, NULL);
BufferIn.dwHeadersLength = hdr.length();
BufferIn.lpcszHeader = hdr.c_str();
double totSize = BufferIn.dwBufferTotal;
if (!HttpSendRequestEx( hRequest, &BufferIn, NULL, 0, 0)) {
CloseHandle(hFile);
InternetCloseHandle(hRequest);
return false;
}
DWORD sum = 0;
do {
if (!ReadFile (hFile, pBuffer, sizeof(pBuffer), &dwBytesRead, NULL)) {
CloseHandle(hFile);
InternetCloseHandle(hRequest);
return false;
}
if (dwBytesRead > 0) {
if (!InternetWriteFile(hRequest, pBuffer, dwBytesRead, &dwBytesWritten)) {
CloseHandle(hFile);
InternetCloseHandle(hRequest);
return false;
}
}
sum += dwBytesWritten;
try {
pw.setProgress(int(1000 * double(sum) / totSize));
}
catch (std::exception &) {
CloseHandle(hFile);
InternetCloseHandle(hRequest);
throw;
}
}
while (dwBytesRead == sizeof(pBuffer)) ;
CloseHandle(hFile);
if (!HttpEndRequest(hRequest, NULL, 0, 0)) {
DWORD error = GetLastError();
if (error == ERROR_INTERNET_FORCE_RETRY)
retry--;
else if (error == ERROR_INTERNET_TIMEOUT) {
throw std::exception("Fick inget svar i tid (ERROR_INTERNET_TIMEOUT)");
}
else {
InternetCloseHandle(hRequest);
return false;
}
}
else
retry = 0; // Done
}
DWORD dwStatus = 0;
DWORD dwBufLen = sizeof(dwStatus);
int success = HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER,
(LPVOID)&dwStatus, &dwBufLen, 0);
if (success) {
if (dwStatus >= 400) {
char bf[256];
switch (dwStatus) {
case HTTP_STATUS_BAD_REQUEST:
sprintf_s(bf, "HTTP Error 400: The request could not be processed by the server due to invalid syntax.");
break;
case HTTP_STATUS_DENIED:
sprintf_s(bf, "HTTP Error 401: The requested resource requires user authentication.");
break;
case HTTP_STATUS_FORBIDDEN:
sprintf_s(bf, "HTTP Error 403: Åtkomst nekad (access is denied).");
break;
case HTTP_STATUS_NOT_FOUND:
sprintf_s(bf, "HTTP Error 404: Resursen kunde ej hittas (not found).");
break;
case HTTP_STATUS_NOT_SUPPORTED:
sprintf_s(bf, "HTTP Error 501: Förfrågan stöds ej (not supported).");
break;
case HTTP_STATUS_SERVER_ERROR:
sprintf_s(bf, "HTTP Error 500: Internt serverfel (server error).");
break;
default:
sprintf_s(bf, "HTTP Status Error %d", dwStatus);
}
throw dwException(bf, dwStatus);
}
}
int fileno = _open(outFile.c_str(), O_BINARY|O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE);
do {
dwBytesRead=0;
if (InternetReadFile(hRequest, pBuffer, sizeof(pBuffer)-1, &dwBytesRead)) {
_write(fileno, pBuffer, dwBytesRead);
}
} while(dwBytesRead>0);
_close(fileno);
InternetCloseHandle(hRequest);
return true;
}
void mechon_mamre_action_page (HtmlWriter2& htmlwriter)
{
htmlwriter.heading_open (3);
htmlwriter.text_add (_("Hebrew import from Mechon Mamre"));
htmlwriter.heading_close ();
vector <ustring> messages;
bool keep_going = true;
// Locate the downloaded file.
ustring ct005zipfilename = gw_build_filename (g_get_home_dir (), "ct005.zip");
messages.push_back (_("Looking for file ") + ct005zipfilename);
if (!g_file_test (ct005zipfilename.c_str(), G_FILE_TEST_IS_REGULAR)) {
ct005zipfilename.clear();
}
if (ct005zipfilename.empty()) {
ct005zipfilename = gw_build_filename (g_get_home_dir (), "Desktop", "ct005.zip");
messages.push_back (_("Looking for file ") + ct005zipfilename);
if (!g_file_test (ct005zipfilename.c_str(), G_FILE_TEST_IS_REGULAR)) {
ct005zipfilename.clear();
}
}
if (ct005zipfilename.empty()) {
ct005zipfilename = gw_build_filename (g_get_home_dir (), "Downloads", "ct005.zip");
messages.push_back (_("Looking for file ") + ct005zipfilename);
if (!g_file_test (ct005zipfilename.c_str(), G_FILE_TEST_IS_REGULAR)) {
ct005zipfilename.clear();
}
}
if (ct005zipfilename.empty()) {
messages.push_back (_("Can't find Hebrew input file"));
keep_going = false;
}
if (keep_going) {
messages.push_back (_("Using file ") + ct005zipfilename);
}
// Unpack the zipped file.
ustring directory;
if (keep_going) {
directory = gw_build_filename (Directories->get_temp (), "uncompress");
unix_rmdir (directory);
gw_mkdir_with_parents (directory);
if (!uncompress (ct005zipfilename, directory)) {
messages.push_back (_("Could not unpack the file"));
keep_going = false;
}
messages.push_back (_("Unpacking into folder ") + directory);
}
// Show the readme file.
if (keep_going) {
ustring readmefile = gw_build_filename (directory, "readme.txt");
ReadText rt (readmefile, true, true);
ustring line;
for (unsigned int i = 0; i < rt.lines.size(); i++) {
if (rt.lines[i].empty()) {
if (!line.empty()) {
messages.push_back (line);
line.clear();
}
} else {
line.append (rt.lines[i] + " ");
}
}
messages.push_back (line);
}
// Look for the directory where all the html files reside.
if (keep_going) {
directory = gw_build_filename (directory, "c", "ct");
if (!g_file_test (directory.c_str(), G_FILE_TEST_IS_DIR)) {
messages.push_back (_("Can't find data in directory ") + directory);
}
messages.push_back (_("Looking for data in directory ") + directory);
}
// Get a list of the html files that have the data.
vector <ustring> files;
if (keep_going) {
ReadFiles rf (directory, "c", ".htm");
for (unsigned int i = 0; i < rf.files.size(); i++) {
ustring filename = gw_build_filename (directory, rf.files[i]);
// Check on a few characteristics.
if (mechon_mamre_copyright(filename)) {
unsigned int digitcount = digit_count_in_string(rf.files[i]);
if ((digitcount == 3) || (digitcount == 4)) {
files.push_back(filename);
}
}
}
}
// Create a new Bible into which to import the data.
ustring bible = _("Hebrew Mechon Mamre");
if (keep_going) {
if (project_exists (bible)) {
messages.push_back (_("A Bible already exists by this name: ") + bible);
keep_going = false;
} else {
project_create_restore (bible, "");
messages.push_back (_("Creating a new Bible called \"") + bible + "\"");
// Make a couple of settings.
extern Settings * settings;
ProjectConfiguration * projectconfig = settings->projectconfig (bible);
projectconfig->versification_set ("Original");
projectconfig->editable_set (false);
projectconfig->right_to_left_set (true);
projectconfig->spelling_check_set (false);
}
}
// Store all the chapters 0 in each book.
if (keep_going) {
vector <unsigned int> books = books_type_to_ids(btOldTestament);
ProgressWindow progresswindow (_("Creating books"), false);
progresswindow.set_iterate (0, 1, books.size());
for (unsigned int bk = 0; bk < books.size(); bk++) {
progresswindow.iterate ();
vector <ustring> usfm;
usfm.push_back ("\\id " + books_id_to_paratext (books[bk]));
CategorizeChapterVerse ccv (usfm);
project_store_chapter (bible, books[bk], ccv);
}
}
// Store all the chapters.
if (keep_going) {
ProgressWindow progresswindow (_("Importing chapters"), false);
progresswindow.set_iterate (0, 1, files.size());
for (unsigned int i = 0; i < files.size(); i++) {
progresswindow.iterate ();
unsigned int book = 0;
unsigned int chapter = 0;
mechon_mamre_extract_book_chapter (files[i], book, chapter);
vector <ustring> contents = mechon_mamre_extract_contents (files[i], chapter);
CategorizeChapterVerse ccv (contents);
project_store_chapter (bible, book, ccv);
messages.push_back (_("Importing ") + books_id_to_localname (book) + " " + convert_to_string (chapter) + _(" from file ") + files[i]);
}
}
// Write accumulated messages.
htmlwriter.heading_open (3);
if (keep_going) {
htmlwriter.text_add (_("Success! Bible was created: ") + bible);
} else {
htmlwriter.text_add (_("Error!"));
}
htmlwriter.heading_close ();
if (keep_going) {
htmlwriter.paragraph_open ();
htmlwriter.text_add (_("To view the Hebrew text, open the Bible in the editor. Optionally set the font for better display of the Hebrew text. A donation made to Mechon Mamre will support their work."));
htmlwriter.paragraph_close ();
}
for (unsigned int i = 0; i < messages.size(); i++) {
htmlwriter.paragraph_open ();
htmlwriter.text_add (messages[i]);
htmlwriter.paragraph_close ();
}
// Write OK.
htmlwriter.paragraph_open ();
htmlwriter.hyperlink_add ("ok", _("Ok"));
htmlwriter.paragraph_close ();
}
void GwSpawn::run()
{
describe();
// Working directory.
const gchar *workingdirectory = NULL;
if (!myworkingdirectory.empty())
workingdirectory = myworkingdirectory.c_str();
// Store arguments in argv.
char *argv[myarguments.size() + 2];
// I know these casts are ugly. To do: figure out a better way.
argv[0] = (char *)myprogram.c_str();
for (unsigned int i = 0; i < myarguments.size(); i++) {
argv[i + 1] = (char *)myarguments[i].c_str();
}
// Terminate argv.
argv[myarguments.size() + 1] = NULL;
// Spawn flags.
int flags = G_SPAWN_SEARCH_PATH;
if (mydevnull) {
flags |= (G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL);
}
// Possible pipes.
gint standard_input_filedescriptor = 0;
gint standard_output_filedescriptor;
gint standard_error_filedescriptor;
gint *standard_input_filedescriptor_pointer = NULL;
gint *standard_output_filedescriptor_pointer = NULL;
gint *standard_error_filedescriptor_pointer = NULL;
gchar *standard_output = NULL;
gchar *standard_error = NULL;
gchar **standard_output_pointer = NULL;
gchar **standard_error_pointer = NULL;
if (myread) {
standard_output_filedescriptor_pointer = &standard_output_filedescriptor;
standard_error_filedescriptor_pointer = &standard_error_filedescriptor;
standard_output_pointer = &standard_output;
standard_error_pointer = &standard_error;
}
if (!mywrite.empty()) {
standard_input_filedescriptor_pointer = &standard_input_filedescriptor;
}
// Spawn process.
if (myasync) {
result = g_spawn_async_with_pipes(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, &pid, standard_input_filedescriptor_pointer, standard_output_filedescriptor_pointer, standard_error_filedescriptor_pointer, NULL);
// Handle writing to stdin.
if (standard_input_filedescriptor) {
tiny_spawn_write(standard_input_filedescriptor, mywrite);
close(standard_input_filedescriptor);
}
} else {
result = g_spawn_sync(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, standard_output_pointer, standard_error_pointer, &exitstatus, NULL);
}
// Handle case we didn't spawn the process.
if (!result) {
exitstatus = -1;
ustring message = myprogram;
message.append(_(" didn't spawn"));
gw_critical(message);
return;
}
// Handle progress function.
if (myprogress || standard_input_filedescriptor) {
ProgressWindow *progresswindow = NULL;
if (myprogress)
progresswindow = new ProgressWindow(mytext, myallowcancel);
ustring filename = gw_build_filename("/proc", convert_to_string(pid));
while (g_file_test(filename.c_str(), G_FILE_TEST_EXISTS)) {
if (progresswindow) {
progresswindow->pulse();
if (progresswindow->cancel) {
unix_kill(pid);
cancelled = true;
}
}
g_usleep(500000);
}
// Close pid.
g_spawn_close_pid(pid);
if (progresswindow) { delete progresswindow; }
}
// Handle reading the output.
if (myread) {
// In async mode we've got file descriptors, and in sync mode we have
// gchar * output.
// If async mode, read the output and close the descriptors.
if (myasync) {
GIOChannel *channel_out = g_io_channel_unix_new(standard_output_filedescriptor);
g_io_channel_read_to_end(channel_out, &standard_output, NULL, NULL);
g_io_channel_shutdown(channel_out, false, NULL);
GIOChannel *channel_err = g_io_channel_unix_new(standard_error_filedescriptor);
g_io_channel_read_to_end(channel_err, &standard_error, NULL, NULL);
g_io_channel_shutdown(channel_err, false, NULL);
}
ParseLine parse_out(standard_output);
standardout = parse_out.lines;
ParseLine parse_err(standard_error);
standarderr = parse_err.lines;
// Free data.
if (standard_output)
g_free(standard_output);
if (standard_error)
g_free(standard_error);
}
}
void SetProgressPosition(unsigned position) override {
progress.SetValue(position);
}
void SetProgressRange(unsigned range) override {
progress.SetRange(0, range);
}
void SetText(const TCHAR *text) override {
progress.SetMessage(text);
}
void RemoteRepositoryAssistant::on_button_push ()
/*
It copies the existing data, without the .git directory, into the persistent clone,
replaces any data that was there, and then pushes this data to the remote repository.
This makes the remote repository to have an exact copy of our data.
*/
{
// Progress.
ProgressWindow progresswindow (_("Pushing your data"), false);
progresswindow.set_fraction (0.2);
// Copy our data into a temporal location.
ustring my_data_directory = notes_shared_storage_folder ();
if (bible_notes_selector_bible ())
my_data_directory = project_data_directory_project(bible);
ustring temporal_data_directory = git_testing_directory ("mydata");
unix_cp_r (my_data_directory, temporal_data_directory);
// In rare cases a .git directory could have been copied along with our data. Remove that.
unix_rmdir (gw_build_filename (temporal_data_directory, ".git"));
// Remove all directories and all files from the persistent clone directory, but leave the .git directory
{
ReadDirectories rd (persistent_clone_directory, "", "");
for (unsigned int i = 0; i < rd.directories.size(); i++) {
if (rd.directories[i] != ".git") {
unix_rmdir (gw_build_filename (persistent_clone_directory, rd.directories[i]));
}
}
ReadFiles rf (persistent_clone_directory, "", "");
for (unsigned int i = 0; i < rf.files.size(); i++) {
unlink (gw_build_filename (persistent_clone_directory, rf.files[i]).c_str());
}
}
// Move our data, from its temporal location, into the persistent clone directory.
progresswindow.set_fraction (0.4);
{
ReadDirectories rd (temporal_data_directory, "", "");
for (unsigned int i = 0; i < rd.directories.size(); i++) {
unix_mv (gw_build_filename (temporal_data_directory, rd.directories[i]), persistent_clone_directory);
}
ReadFiles rf (temporal_data_directory, "", "");
for (unsigned int i = 0; i < rf.files.size(); i++) {
unix_mv (gw_build_filename (temporal_data_directory, rf.files[i]), persistent_clone_directory);
}
}
// Commit the new data in the persistent clone directory.
progresswindow.set_fraction (0.55);
{
GwSpawn spawn ("git");
spawn.workingdirectory (persistent_clone_directory);
spawn.arg ("add");
spawn.arg (".");
spawn.run ();
}
progresswindow.set_fraction (0.65);
{
GwSpawn spawn ("git");
spawn.workingdirectory (persistent_clone_directory);
spawn.arg ("commit");
spawn.arg ("-a");
spawn.arg ("-m");
spawn.arg ("user data into repo");
spawn.run ();
}
// Push our data to the remote repository.
progresswindow.set_fraction (0.8);
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg ("push");
spawn.run();
// Take action depending on the outcome of pushing to the remote repository.
if (spawn.exitstatus == 0) {
// Clone okay.
gtk_label_set_text (GTK_LABEL (label_push), _("Your data has been pushed to the remote repository"));
} else {
// Clone failed.
gtk_label_set_text (GTK_LABEL (label_push), _("Your data could not be pushed to the remote repository,\nplease restart the assistant"));
repository_unclone();
}
}
void RemoteRepositoryAssistant::test_write_access ()
// Checks whether there is write access from the local clone to the remote repository.
{
// GUI update.
// If a wrong host is entered as the git repository, the testing for the write access
// may "hang" for a long time. For that reason it can be cancelled by the user.
ProgressWindow progresswindow (_("Testing write access"), true);
gtk_label_set_text (GTK_LABEL (label_write_test), _("Testing write access to the remote repository"));
// Temporal file for trying write access.
ustring filename = "test_repository_writable";
g_file_set_contents(gw_build_filename(persistent_clone_directory, filename).c_str(), "", 0, NULL);
// Add this file and commit it locally.
progresswindow.set_fraction (0.2);
{
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg("add");
spawn.arg(".");
spawn.run();
write_access_granted = (spawn.exitstatus == 0);
}
if (write_access_granted) {
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg("commit");
spawn.arg("-m");
spawn.arg("Write test");
spawn.arg("-a");
spawn.run();
write_access_granted = (spawn.exitstatus == 0);
}
// Pull changes.
progresswindow.set_fraction (0.4);
if (write_access_granted) {
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg ("pull");
spawn.run();
// When pulling from an empty repository, the exit status is undefined.
// So we cannot test for it here.
// write_access_granted = (spawn.exitstatus == 0);
}
// Push the changes to see if there is write access.
// Notice the --all switch to be used when pushing to an empty remote repository.
progresswindow.set_fraction (0.6);
if (write_access_granted) {
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg ("push");
spawn.arg ("--all");
spawn.run();
write_access_granted = (spawn.exitstatus == 0);
}
// Remove the temporal file again from the remote repository.
progresswindow.set_fraction (0.8);
unlink(gw_build_filename(persistent_clone_directory, filename).c_str());
if (write_access_granted) {
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg("commit");
spawn.arg("-m");
spawn.arg("Write test");
spawn.arg("-a");
spawn.run();
write_access_granted = (spawn.exitstatus == 0);
}
progresswindow.set_fraction (1);
if (write_access_granted) {
GwSpawn spawn("git");
spawn.workingdirectory(persistent_clone_directory);
spawn.arg ("push");
spawn.run();
write_access_granted = (spawn.exitstatus == 0);
}
// Set the GUI.
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_write_test, write_access_granted);
if (write_access_granted) {
gtk_label_set_text (GTK_LABEL (label_write_test), _("Write access was granted, you can go forward"));
} else {
gtk_label_set_text (GTK_LABEL (label_write_test), _("No write access. Please check the system log for more information"));
}
}
bool RemoteRepositoryAssistant::try_git ()
// Tries git and returns true if everything's fine.
{
// Progress.
ProgressWindow progresswindow (_("Trying the contents tracker"), false);
// Whether git is okay.
bool okay = true;
if (okay) {
progresswindow.set_fraction (0.05);
gw_message (_("Check git version number"));
okay = check_git_version ();
}
// Clean the directory to work in.
{
ustring directory = git_testing_directory ("");
unix_rmdir (directory);
gw_mkdir_with_parents (directory);
}
if (okay) {
progresswindow.set_fraction (0.11);
gw_message (_("Create first local repository"));
okay = try_git_create_repository ("local1", false);
}
if (okay) {
progresswindow.set_fraction (0.17);
gw_message (_("Store data into first local repository"));
okay = try_git_store_data_in_repository ("local1", "--test--");
}
if (okay) {
progresswindow.set_fraction (0.23);
gw_message (_("Create remote repository"));
okay = try_git_create_repository ("remote", true);
}
if (okay) {
progresswindow.set_fraction (0.29);
gw_message (_("Fetch data from the first local repository into the remote one"));
okay = try_git_fetch_repository ("remote", "local1");
}
if (okay) {
progresswindow.set_fraction (0.35);
gw_message (_("Checkout the first local repository"));
okay = try_git_checkout_repository ("local1", "remote");
}
if (okay) {
progresswindow.set_fraction (0.41);
gw_message (_("Check data of first local repository"));
okay = try_git_check_data_in_repository ("local1", "--test--");
}
if (okay) {
progresswindow.set_fraction (0.47);
gw_message (_("Checkout the second local repository"));
okay = try_git_checkout_repository ("local2", "remote");
}
if (okay) {
progresswindow.set_fraction (0.52);
gw_message (_("Check data of second local repository"));
okay = try_git_check_data_in_repository ("local2", "--test--");
}
if (okay) {
progresswindow.set_fraction (0.58);
gw_message (_("Store different data into first repository"));
okay = try_git_store_data_in_repository ("local1", "---test---");
}
if (okay) {
progresswindow.set_fraction (0.64);
gw_message (_("Push first repository"));
okay = try_git_push_repository ("local1");
}
if (okay) {
progresswindow.set_fraction (0.70);
gw_message (_("Pull second repository"));
okay = try_git_pull_repository ("local2");
}
if (okay) {
progresswindow.set_fraction (0.76);
gw_message ("Check data in second repository");
okay = try_git_check_data_in_repository ("local2", "---test---");
}
if (okay) {
progresswindow.set_fraction (0.82);
gw_message (_("Store different data into second repository"));
okay = try_git_store_data_in_repository ("local2", "----test----");
}
if (okay) {
progresswindow.set_fraction (0.88);
gw_message (_("Push second repository"));
okay = try_git_push_repository ("local2");
}
if (okay) {
progresswindow.set_fraction (0.94);
gw_message (_("Pull first repository"));
okay = try_git_pull_repository ("local1");
}
if (okay) {
progresswindow.set_fraction (1);
gw_message (_("Check data in first repository"));
okay = try_git_check_data_in_repository ("local1", "----test----");
}
// Return whether git is ok.
return okay;
}
