// ============================================================= // // // // File : dbserver.cxx // // Purpose : // // // // Coded by Ralf Westram (coder@reallysoft.de) in April 2013 // // Institute of Microbiology (Technical University Munich) // // http://www.arb-home.de/ // // // // ============================================================= // #include "trackers.hxx" #include "dbserver.hxx" #include "macros.hxx" #include #include #include #include #include #include #if defined(DEBUG) // # define DUMP_REMOTE_ACTIONS // # define DUMP_AUTHORIZATION // see also ../../ARBDB/adtools.cxx@DUMP_AUTH_HANDSHAKE #endif #if defined(DUMP_REMOTE_ACTIONS) # define IF_DUMP_ACTION(cmd) cmd #else # define IF_DUMP_ACTION(cmd) #endif #if defined(DUMP_AUTHORIZATION) # define IF_DUMP_AUTH(cmd) cmd #else # define IF_DUMP_AUTH(cmd) #endif #define ARB_SERVE_DB_TIMER 50 // ms #define ARB_CHECK_DB_TIMER 200 // ms struct db_interrupt_data : virtual Noncopyable { remote_awars remote; GBDATA *gb_main; db_interrupt_data(GBDATA *gb_main_, const char *application_id) : remote(application_id), gb_main(gb_main_) {} GB_ERROR reconfigure(GBDATA *gb_main_, const char *application_id) { GB_ERROR error = NULp; if (gb_main_ != gb_main) { error = "Attempt to reconfigure database interrupt with changed database"; } else { remote = remote_awars(application_id); } return error; } }; __ATTR__USERESULT static GB_ERROR check_for_remote_command(AW_root *aw_root, const db_interrupt_data& dib) { // @@@ split into several functions arb_assert(!GB_have_error()); GB_ERROR error = NULp; GBDATA *gb_main = dib.gb_main; GB_push_transaction(gb_main); // @@@ begin required/possible here? if (GB_is_server(gb_main)) { char *client_action = GBT_readOrCreate_string(gb_main, MACRO_TRIGGER_TRACKED, ""); if (client_action && client_action[0]) { UserActionTracker *tracker = aw_root->get_tracker(); MacroRecorder *macroRecorder = dynamic_cast(tracker); error = macroRecorder->handle_tracked_client_action(client_action); GB_ERROR trig_error = GBT_write_string(gb_main, MACRO_TRIGGER_TRACKED, ""); // tell client that action has been recorded if (!error) error = trig_error; } free(client_action); if (!error) { GB_ERROR macro_error = GB_get_macro_error(gb_main); if (macro_error) { UserActionTracker *tracker = aw_root->get_tracker(); MacroRecorder *macroRecorder = dynamic_cast(tracker); if (macroRecorder->is_tracking()) { // only handle recording error here aw_message(GBS_global_string("%s\n" "macro recording aborted", macro_error)); error = macroRecorder->stop_recording(); GB_ERROR clr_error = GB_clear_macro_error(gb_main); if (!error) error = clr_error; } } } } if (error) { GB_pop_transaction(gb_main); } else { const remote_awars& remote = dib.remote; long *granted = GBT_readOrCreate_int(gb_main, remote.granted(), 0); pid_t pid = getpid(); bool authorized = granted && *granted == pid; if (!authorized) { if (!granted) error = GBS_global_string("Failed to access '%s'", remote.granted()); else { arb_assert(*granted != pid); // @@@ differ between *granted == 0 and *granted != 0? long *authReq = GBT_readOrCreate_int(gb_main, remote.authReq(), 0); if (!authReq) error = GBS_global_string("Failed to access '%s'", remote.authReq()); else if (*authReq) { GBDATA *gb_authAck = GB_searchOrCreate_int(gb_main, remote.authAck(), 0); if (!gb_authAck) error = GBS_global_string("Failed to access '%s'", remote.authAck()); else { pid_t authAck = GB_read_int(gb_authAck); if (authAck == 0) { // ack this process can execute remote commands error = GB_write_int(gb_authAck, pid); IF_DUMP_AUTH(fprintf(stderr, "acknowledging '%s' with pid %i\n", remote.authAck(), pid)); } else if (authAck == pid) { // already acknowledged -- wait } else { // another process with same app-id acknowledged faster IF_DUMP_AUTH(fprintf(stderr, "did not acknowledge '%s' with pid %i (pid %i was faster)\n", remote.authAck(), pid, authAck)); const char *merr = GBS_global_string("Detected two clients with id '%s'", remote.appID()); error = GB_set_macro_error(gb_main, merr); } } } } error = GB_end_transaction(gb_main, error); } else { char *action = GBT_readOrCreate_string(gb_main, remote.action(), ""); char *value = GBT_readOrCreate_string(gb_main, remote.value(), ""); char *tmp_awar = GBT_readOrCreate_string(gb_main, remote.awar(), ""); if (tmp_awar[0]) { AW_awar *found_awar = aw_root->awar_no_error(tmp_awar); if (!found_awar) { error = GBS_global_string("Unknown variable '%s'", tmp_awar); } else { if (strcmp(action, "AWAR_REMOTE_READ") == 0) { char *read_value = aw_root->awar(tmp_awar)->read_as_string(); GBT_write_string(gb_main, remote.value(), read_value); IF_DUMP_ACTION(printf("remote command 'AWAR_REMOTE_READ' awar='%s' value='%s'\n", tmp_awar, read_value)); free(read_value); action[0] = 0; // clear action (AWAR_REMOTE_READ is just a pseudo-action) : GBT_write_string(gb_main, remote.action(), ""); } else if (strcmp(action, "AWAR_REMOTE_TOUCH") == 0) { GB_set_remote_action(gb_main, true); aw_root->awar(tmp_awar)->touch(); GB_set_remote_action(gb_main, false); IF_DUMP_ACTION(printf("remote command 'AWAR_REMOTE_TOUCH' awar='%s'\n", tmp_awar)); action[0] = 0; // clear action (AWAR_REMOTE_TOUCH is just a pseudo-action) : GBT_write_string(gb_main, remote.action(), ""); } else { IF_DUMP_ACTION(printf("remote command (write awar) awar='%s' value='%s'\n", tmp_awar, value)); GB_set_remote_action(gb_main, true); error = aw_root->awar(tmp_awar)->write_as_string(value); GB_set_remote_action(gb_main, false); } } GBT_write_string(gb_main, remote.result(), null2empty(error)); GBT_write_string(gb_main, remote.awar(), ""); // tell perl-client call has completed (BIO::remote_awar and BIO:remote_read_awar) aw_message_if(error); } GB_pop_transaction(gb_main); // @@@ end required/possible here? arb_assert(!GB_have_error()); // error exported by some callback? (unwanted) if (action[0]) { AW_cb *act = aw_root->search_remote_command(action); if (act) { IF_DUMP_ACTION(printf("remote command (%s) found, running callback\n", action)); arb_assert(!GB_have_error()); GB_set_remote_action(gb_main, true); act->run_callbacks(); GB_set_remote_action(gb_main, false); arb_assert(!GB_have_error()); // error exported by callback (unwanted) GBT_write_string(gb_main, remote.result(), ""); } else { IF_DUMP_ACTION(printf("remote command (%s) is unknown\n", action)); error = GBS_global_string("Unknown action '%s' in macro", action); GBT_write_string(gb_main, remote.result(), error); } GBT_write_string(gb_main, remote.action(), ""); // tell perl-client call has completed (remote_action) } free(tmp_awar); free(value); free(action); } } arb_assert(!GB_have_error()); if (error) fprintf(stderr, "Error in check_for_remote_command: %s\n", error); return error; } inline bool remote_command_handler(AW_root *awr, const db_interrupt_data& dib) { // returns false in case of errors arb_assert(!GB_have_error()); bool ok = true; GB_ERROR error = check_for_remote_command(awr, dib); if (error) { aw_message(error); ok = false; } return ok; } static unsigned serve_db_interrupt(AW_root *awr, db_interrupt_data *dib) { // server // always serves database connections (from clients). // if awr!=null => also executes remote commands (normally from macro-clients) // // Possible improvement: maybe abort the following loop after some time? // otherwise: if a client polls too fast, the GUI of the server may lock bool success = GBCMS_accept_calls(dib->gb_main, false); while (success) { success = (!awr || remote_command_handler(awr, *dib)) && GBCMS_accept_calls(dib->gb_main, true); } return ARB_SERVE_DB_TIMER; } static unsigned check_db_interrupt(AW_root *awr, db_interrupt_data *dib) { // client remote_command_handler(awr, *dib); return ARB_CHECK_DB_TIMER; } // -------------------------------------------------------------------------------- static db_interrupt_data *idle_interrupt = NULp; GB_ERROR startup_dbserver(AW_root *aw_root, const char *application_id, GBDATA *gb_main) { #if defined(DEBUG) static bool initialized = false; arb_assert(!initialized); // called twice - not able (yet) initialized = true; #endif arb_assert(got_macro_ability(aw_root)); GB_ERROR error = NULp; if (GB_read_clients(gb_main) == 0) { // server error = GBCMS_open(":", 0, gb_main); if (error) { error = GBS_global_string("THIS PROGRAM HAS PROBLEMS TO OPEN INTERCLIENT COMMUNICATION:\n" "Reason: %s\n" "(maybe there is already another server running)\n" "You cannot use any EDITOR or other external SOFTWARE from here.\n" "Advice: Close ARB again, open a console, type 'arb_clean' and restart arb.\n" "Caution: Any unsaved data in an eventually running ARB will be lost.\n", error); } else { idle_interrupt = new db_interrupt_data(gb_main, application_id); aw_root->add_timed_callback(ARB_SERVE_DB_TIMER, makeTimedCallback(serve_db_interrupt, idle_interrupt)); } } else { // client idle_interrupt = new db_interrupt_data(gb_main, application_id); aw_root->add_timed_callback(ARB_CHECK_DB_TIMER, makeTimedCallback(check_db_interrupt, idle_interrupt)); } if (!error) { // handle remote commands once (to create DB-entries; w/o they are created after startup of first DB-client) arb_assert(idle_interrupt); if (idle_interrupt) remote_command_handler(aw_root, *idle_interrupt); } return error; } GB_ERROR reconfigure_dbserver(const char *application_id, GBDATA *gb_main) { // reconfigures a running dbserver (started with startup_dbserver) arb_assert(idle_interrupt); // not started yet return idle_interrupt->reconfigure(gb_main, application_id); } GB_ERROR serve_db_while_GUI_is_blocked(GBDATA *gb_main) { GB_ERROR error = NULp; if (!idle_interrupt) { error = "called to early"; } else if (idle_interrupt->gb_main != gb_main) { error = "detected multiple arb databases"; } else if (!GB_is_server(gb_main)) { error = "i am not server"; } else { // serve client requests w/o handling remote commands // => macro does not continue serve_db_interrupt(NULp, idle_interrupt); } if (error) { error = GBS_global_string("cannot serve DB (Reason: %s)", error); } return error; }